Untitled Collection
DELETE
Cancel the most recent user action for the specified domain
{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type
QUERY PARAMS
customerId
domain
type
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type")require "http/client"
url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/v2/customers/:customerId/domains/:domain/actions/:type HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/customers/:customerId/domains/:domain/actions/:type',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type');
echo $response->getBody();setUrl('{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/v2/customers/:customerId/domains/:domain/actions/:type")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/v2/customers/:customerId/domains/:domain/actions/:type') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:typehttp DELETE {{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:typewget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:typeimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieves a list of the most recent actions for the specified domain
{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions
QUERY PARAMS
customerId
domain
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions")require "http/client"
url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v2/customers/:customerId/domains/:domain/actions HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/customers/:customerId/domains/:domain/actions',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions');
echo $response->getBody();setUrl('{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v2/customers/:customerId/domains/:domain/actions")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v2/customers/:customerId/domains/:domain/actions') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v2/customers/:customerId/domains/:domain/actionshttp GET {{baseUrl}}/v2/customers/:customerId/domains/:domain/actionswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v2/customers/:customerId/domains/:domain/actionsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieves the most recent action for the specified domain
{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type
QUERY PARAMS
customerId
domain
type
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type")require "http/client"
url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v2/customers/:customerId/domains/:domain/actions/:type HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/customers/:customerId/domains/:domain/actions/:type',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type');
echo $response->getBody();setUrl('{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v2/customers/:customerId/domains/:domain/actions/:type")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v2/customers/:customerId/domains/:domain/actions/:type') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:typehttp GET {{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:typewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:typeimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/customers/:customerId/domains/:domain/actions/:type")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create a new forwarding configuration for the given FQDN
{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn
QUERY PARAMS
customerId
fqdn
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")require "http/client"
url = "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v2/customers/:customerId/domains/forwards/:fqdn HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/customers/:customerId/domains/forwards/:fqdn',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
echo $response->getBody();setUrl('{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/v2/customers/:customerId/domains/forwards/:fqdn")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/v2/customers/:customerId/domains/forwards/:fqdn') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdnhttp POST {{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdnwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdnimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Initiate transfer out to another registrar for a .uk domain.
{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut
QUERY PARAMS
registrar
customerId
domain
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut" {:query-params {:registrar ""}})require "http/client"
url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar="
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar="
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v2/customers/:customerId/domains/:domain/transferOut?registrar= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar="))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut',
params: {registrar: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/customers/:customerId/domains/:domain/transferOut?registrar=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut',
qs: {registrar: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut');
req.query({
registrar: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut',
params: {registrar: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=');
echo $response->getBody();setUrl('{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut');
$request->setMethod(HTTP_METH_POST);
$request->setQueryData([
'registrar' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
'registrar' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/v2/customers/:customerId/domains/:domain/transferOut?registrar=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut"
querystring = {"registrar":""}
response = requests.post(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut"
queryString <- list(registrar = "")
response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/v2/customers/:customerId/domains/:domain/transferOut') do |req|
req.params['registrar'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut";
let querystring = [
("registrar", ""),
];
let client = reqwest::Client::new();
let response = client.post(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar='http POST '{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar='wget --quiet \
--method POST \
--output-document \
- '{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/customers/:customerId/domains/:domain/transferOut?registrar=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Modify the forwarding information for the given fqdn
{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn
QUERY PARAMS
customerId
fqdn
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")require "http/client"
url = "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/v2/customers/:customerId/domains/forwards/:fqdn HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"))
.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}}/v2/customers/:customerId/domains/forwards/:fqdn")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
.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}}/v2/customers/:customerId/domains/forwards/:fqdn');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/customers/:customerId/domains/forwards/:fqdn',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
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}}/v2/customers/:customerId/domains/forwards/:fqdn'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
echo $response->getBody();setUrl('{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/v2/customers/:customerId/domains/forwards/:fqdn")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/v2/customers/:customerId/domains/forwards/:fqdn') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdnhttp PUT {{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdnwget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdnimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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
Purchase a restore for the given domain to bring it out of redemption
{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem
QUERY PARAMS
customerId
domain
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem")require "http/client"
url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v2/customers/:customerId/domains/:domain/redeem HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/customers/:customerId/domains/:domain/redeem',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem');
echo $response->getBody();setUrl('{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/v2/customers/:customerId/domains/:domain/redeem")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/v2/customers/:customerId/domains/:domain/redeem') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v2/customers/:customerId/domains/:domain/redeemhttp POST {{baseUrl}}/v2/customers/:customerId/domains/:domain/redeemwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/v2/customers/:customerId/domains/:domain/redeemimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/customers/:customerId/domains/:domain/redeem")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve a list of upcoming system Maintenances
{{baseUrl}}/v2/domains/maintenances
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/domains/maintenances");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v2/domains/maintenances")require "http/client"
url = "{{baseUrl}}/v2/domains/maintenances"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v2/domains/maintenances"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/domains/maintenances");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/domains/maintenances"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v2/domains/maintenances HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/domains/maintenances")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/domains/maintenances"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v2/domains/maintenances")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v2/domains/maintenances")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v2/domains/maintenances');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v2/domains/maintenances'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/domains/maintenances';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/domains/maintenances',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/domains/maintenances")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/domains/maintenances',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v2/domains/maintenances'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v2/domains/maintenances');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/v2/domains/maintenances'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/domains/maintenances';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/domains/maintenances"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/domains/maintenances" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/domains/maintenances",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v2/domains/maintenances');
echo $response->getBody();setUrl('{{baseUrl}}/v2/domains/maintenances');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/domains/maintenances');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/domains/maintenances' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/domains/maintenances' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v2/domains/maintenances")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/domains/maintenances"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/domains/maintenances"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/domains/maintenances")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v2/domains/maintenances') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/domains/maintenances";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v2/domains/maintenanceshttp GET {{baseUrl}}/v2/domains/maintenanceswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v2/domains/maintenancesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/domains/maintenances")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve details for the specified Domain (GET)
{{baseUrl}}/v2/customers/:customerId/domains/:domain
QUERY PARAMS
customerId
domain
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/customers/:customerId/domains/:domain");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v2/customers/:customerId/domains/:domain")require "http/client"
url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v2/customers/:customerId/domains/:domain"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/customers/:customerId/domains/:domain");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/customers/:customerId/domains/:domain"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v2/customers/:customerId/domains/:domain HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/customers/:customerId/domains/:domain")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/customers/:customerId/domains/:domain"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/:domain")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v2/customers/:customerId/domains/:domain")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v2/customers/:customerId/domains/:domain');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/customers/:customerId/domains/:domain';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/:domain")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/customers/:customerId/domains/:domain',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v2/customers/:customerId/domains/:domain');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/:domain'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/customers/:customerId/domains/:domain';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/customers/:customerId/domains/:domain"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/customers/:customerId/domains/:domain" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/customers/:customerId/domains/:domain",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v2/customers/:customerId/domains/:domain');
echo $response->getBody();setUrl('{{baseUrl}}/v2/customers/:customerId/domains/:domain');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/customers/:customerId/domains/:domain');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/customers/:customerId/domains/:domain' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/customers/:customerId/domains/:domain' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v2/customers/:customerId/domains/:domain")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/customers/:customerId/domains/:domain"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/customers/:customerId/domains/:domain")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v2/customers/:customerId/domains/:domain') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/customers/:customerId/domains/:domain";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v2/customers/:customerId/domains/:domainhttp GET {{baseUrl}}/v2/customers/:customerId/domains/:domainwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v2/customers/:customerId/domains/:domainimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/customers/:customerId/domains/:domain")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve the details for an upcoming system Maintenances
{{baseUrl}}/v2/domains/maintenances/:maintenanceId
QUERY PARAMS
maintenanceId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/domains/maintenances/:maintenanceId");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v2/domains/maintenances/:maintenanceId")require "http/client"
url = "{{baseUrl}}/v2/domains/maintenances/:maintenanceId"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v2/domains/maintenances/:maintenanceId"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/domains/maintenances/:maintenanceId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/domains/maintenances/:maintenanceId"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v2/domains/maintenances/:maintenanceId HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/domains/maintenances/:maintenanceId")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/domains/maintenances/:maintenanceId"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v2/domains/maintenances/:maintenanceId")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v2/domains/maintenances/:maintenanceId")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v2/domains/maintenances/:maintenanceId');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/domains/maintenances/:maintenanceId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/domains/maintenances/:maintenanceId';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/domains/maintenances/:maintenanceId',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/domains/maintenances/:maintenanceId")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/domains/maintenances/:maintenanceId',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/domains/maintenances/:maintenanceId'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v2/domains/maintenances/:maintenanceId');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/domains/maintenances/:maintenanceId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/domains/maintenances/:maintenanceId';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/domains/maintenances/:maintenanceId"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/domains/maintenances/:maintenanceId" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/domains/maintenances/:maintenanceId",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v2/domains/maintenances/:maintenanceId');
echo $response->getBody();setUrl('{{baseUrl}}/v2/domains/maintenances/:maintenanceId');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/domains/maintenances/:maintenanceId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/domains/maintenances/:maintenanceId' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/domains/maintenances/:maintenanceId' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v2/domains/maintenances/:maintenanceId")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/domains/maintenances/:maintenanceId"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/domains/maintenances/:maintenanceId"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/domains/maintenances/:maintenanceId")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v2/domains/maintenances/:maintenanceId') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/domains/maintenances/:maintenanceId";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v2/domains/maintenances/:maintenanceIdhttp GET {{baseUrl}}/v2/domains/maintenances/:maintenanceIdwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v2/domains/maintenances/:maintenanceIdimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/domains/maintenances/:maintenanceId")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve the forwarding information for the given fqdn
{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn
QUERY PARAMS
customerId
fqdn
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")require "http/client"
url = "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v2/customers/:customerId/domains/forwards/:fqdn HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/customers/:customerId/domains/forwards/:fqdn',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
echo $response->getBody();setUrl('{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v2/customers/:customerId/domains/forwards/:fqdn")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v2/customers/:customerId/domains/forwards/:fqdn') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdnhttp GET {{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdnwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdnimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Submit a forwarding cancellation request for the given fqdn
{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn
QUERY PARAMS
customerId
fqdn
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")require "http/client"
url = "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/v2/customers/:customerId/domains/forwards/:fqdn HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/customers/:customerId/domains/forwards/:fqdn',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
echo $response->getBody();setUrl('{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/v2/customers/:customerId/domains/forwards/:fqdn")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/v2/customers/:customerId/domains/forwards/:fqdn') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdnhttp DELETE {{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdnwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdnimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/customers/:customerId/domains/forwards/:fqdn")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Acknowledge a domain notification
{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge
QUERY PARAMS
customerId
notificationId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge")require "http/client"
url = "{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge');
echo $response->getBody();setUrl('{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledgehttp POST {{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledgewget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledgeimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/customers/:customerId/domains/notifications/:notificationId/acknowledge")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Opt in to recieve notifications for the submitted notification types
{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn
QUERY PARAMS
types
customerId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn" {:query-params {:types ""}})require "http/client"
url = "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types="
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types=");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types="
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/v2/customers/:customerId/domains/notifications/optIn?types= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types="))
.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}}/v2/customers/:customerId/domains/notifications/optIn?types=")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types=")
.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}}/v2/customers/:customerId/domains/notifications/optIn?types=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn',
params: {types: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types=';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types=',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types=")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/customers/:customerId/domains/notifications/optIn?types=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn',
qs: {types: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn');
req.query({
types: ''
});
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}}/v2/customers/:customerId/domains/notifications/optIn',
params: {types: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types=';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types=" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types=');
echo $response->getBody();setUrl('{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn');
$request->setMethod(HTTP_METH_PUT);
$request->setQueryData([
'types' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn');
$request->setRequestMethod('PUT');
$request->setQuery(new http\QueryString([
'types' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types=' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types=' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/v2/customers/:customerId/domains/notifications/optIn?types=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn"
querystring = {"types":""}
response = requests.put(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn"
queryString <- list(types = "")
response <- VERB("PUT", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/v2/customers/:customerId/domains/notifications/optIn') do |req|
req.params['types'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn";
let querystring = [
("types", ""),
];
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types='http PUT '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types='wget --quiet \
--method PUT \
--output-document \
- '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn?types=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 a list of notification types that are opted in
{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn
QUERY PARAMS
customerId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn")require "http/client"
url = "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v2/customers/:customerId/domains/notifications/optIn HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/customers/:customerId/domains/notifications/optIn',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn');
echo $response->getBody();setUrl('{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v2/customers/:customerId/domains/notifications/optIn")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v2/customers/:customerId/domains/notifications/optIn') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v2/customers/:customerId/domains/notifications/optInhttp GET {{baseUrl}}/v2/customers/:customerId/domains/notifications/optInwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v2/customers/:customerId/domains/notifications/optInimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/customers/:customerId/domains/notifications/optIn")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve the next domain notification
{{baseUrl}}/v2/customers/:customerId/domains/notifications
QUERY PARAMS
customerId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/customers/:customerId/domains/notifications");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v2/customers/:customerId/domains/notifications")require "http/client"
url = "{{baseUrl}}/v2/customers/:customerId/domains/notifications"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v2/customers/:customerId/domains/notifications"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/customers/:customerId/domains/notifications");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/customers/:customerId/domains/notifications"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v2/customers/:customerId/domains/notifications HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/customers/:customerId/domains/notifications")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/customers/:customerId/domains/notifications"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/notifications")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v2/customers/:customerId/domains/notifications")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v2/customers/:customerId/domains/notifications');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/customers/:customerId/domains/notifications';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/notifications")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/customers/:customerId/domains/notifications',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v2/customers/:customerId/domains/notifications');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/customers/:customerId/domains/notifications';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/customers/:customerId/domains/notifications"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/customers/:customerId/domains/notifications" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/customers/:customerId/domains/notifications",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v2/customers/:customerId/domains/notifications');
echo $response->getBody();setUrl('{{baseUrl}}/v2/customers/:customerId/domains/notifications');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/customers/:customerId/domains/notifications');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/customers/:customerId/domains/notifications' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/customers/:customerId/domains/notifications' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v2/customers/:customerId/domains/notifications")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/customers/:customerId/domains/notifications"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/customers/:customerId/domains/notifications"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/customers/:customerId/domains/notifications")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v2/customers/:customerId/domains/notifications') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/customers/:customerId/domains/notifications";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v2/customers/:customerId/domains/notificationshttp GET {{baseUrl}}/v2/customers/:customerId/domains/notificationswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v2/customers/:customerId/domains/notificationsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/customers/:customerId/domains/notifications")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve the schema for the notification data for the specified notification type
{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type
QUERY PARAMS
customerId
type
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type")require "http/client"
url = "{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v2/customers/:customerId/domains/notifications/schemas/:type HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v2/customers/:customerId/domains/notifications/schemas/:type',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type');
echo $response->getBody();setUrl('{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v2/customers/:customerId/domains/notifications/schemas/:type")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v2/customers/:customerId/domains/notifications/schemas/:type') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:typehttp GET {{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:typewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:typeimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/customers/:customerId/domains/notifications/schemas/:type")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Add the specified DNS Records to the specified Domain
{{baseUrl}}/v1/domains/:domain/records
QUERY PARAMS
domain
BODY json
[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
}
]
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/:domain/records");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/v1/domains/:domain/records" {:content-type :json
:form-params [{:data ""
:name ""
:port 0
:priority 0
:protocol ""
:service ""
:ttl 0
:type ""
:weight 0}]})require "http/client"
url = "{{baseUrl}}/v1/domains/:domain/records"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]"
response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/v1/domains/:domain/records"),
Content = new StringContent("[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/:domain/records");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/:domain/records"
payload := strings.NewReader("[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]")
req, _ := http.NewRequest("PATCH", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/v1/domains/:domain/records HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 162
[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
}
]AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1/domains/:domain/records")
.setHeader("content-type", "application/json")
.setBody("[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/:domain/records"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]");
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/records")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/v1/domains/:domain/records")
.header("content-type", "application/json")
.body("[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]")
.asString(); const data = JSON.stringify([
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
type: '',
weight: 0
}
]);
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/v1/domains/:domain/records');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/v1/domains/:domain/records',
headers: {'content-type': 'application/json'},
data: [
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
type: '',
weight: 0
}
]
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/:domain/records';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '[{"data":"","name":"","port":0,"priority":0,"protocol":"","service":"","ttl":0,"type":"","weight":0}]'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/:domain/records',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '[\n {\n "data": "",\n "name": "",\n "port": 0,\n "priority": 0,\n "protocol": "",\n "service": "",\n "ttl": 0,\n "type": "",\n "weight": 0\n }\n]'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]")
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/records")
.patch(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/:domain/records',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify([
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
type: '',
weight: 0
}
]));
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/v1/domains/:domain/records',
headers: {'content-type': 'application/json'},
body: [
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
type: '',
weight: 0
}
],
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/v1/domains/:domain/records');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send([
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
type: '',
weight: 0
}
]);
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/v1/domains/:domain/records',
headers: {'content-type': 'application/json'},
data: [
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
type: '',
weight: 0
}
]
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/:domain/records';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '[{"data":"","name":"","port":0,"priority":0,"protocol":"","service":"","ttl":0,"type":"","weight":0}]'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @[ @{ @"data": @"", @"name": @"", @"port": @0, @"priority": @0, @"protocol": @"", @"service": @"", @"ttl": @0, @"type": @"", @"weight": @0 } ];
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/:domain/records"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/:domain/records" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/:domain/records",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode([
[
'data' => '',
'name' => '',
'port' => 0,
'priority' => 0,
'protocol' => '',
'service' => '',
'ttl' => 0,
'type' => '',
'weight' => 0
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/v1/domains/:domain/records', [
'body' => '[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
}
]',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/:domain/records');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
[
'data' => '',
'name' => '',
'port' => 0,
'priority' => 0,
'protocol' => '',
'service' => '',
'ttl' => 0,
'type' => '',
'weight' => 0
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
[
'data' => '',
'name' => '',
'port' => 0,
'priority' => 0,
'protocol' => '',
'service' => '',
'ttl' => 0,
'type' => '',
'weight' => 0
]
]));
$request->setRequestUrl('{{baseUrl}}/v1/domains/:domain/records');
$request->setRequestMethod('PATCH');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/:domain/records' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
}
]'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/:domain/records' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
}
]'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/v1/domains/:domain/records", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/:domain/records"
payload = [
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
}
]
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/:domain/records"
payload <- "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]"
encode <- "json"
response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/:domain/records")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.patch('/baseUrl/v1/domains/:domain/records') do |req|
req.body = "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/:domain/records";
let payload = (
json!({
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
})
);
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/v1/domains/:domain/records \
--header 'content-type: application/json' \
--data '[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
}
]'echo '[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
}
]' | \
http PATCH {{baseUrl}}/v1/domains/:domain/records \
content-type:application/jsonwget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '[\n {\n "data": "",\n "name": "",\n "port": 0,\n "priority": 0,\n "protocol": "",\n "service": "",\n "ttl": 0,\n "type": "",\n "weight": 0\n }\n]' \
--output-document \
- {{baseUrl}}/v1/domains/:domain/recordsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
[
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
]
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/:domain/records")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Cancel a purchased domain
{{baseUrl}}/v1/domains/:domain
QUERY PARAMS
domain
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/:domain");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/v1/domains/:domain")require "http/client"
url = "{{baseUrl}}/v1/domains/:domain"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/v1/domains/:domain"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/:domain");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/:domain"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/v1/domains/:domain HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/domains/:domain")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/:domain"))
.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}}/v1/domains/:domain")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/v1/domains/:domain")
.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}}/v1/domains/:domain');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/v1/domains/:domain'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/:domain';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/:domain',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/:domain',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'DELETE', url: '{{baseUrl}}/v1/domains/:domain'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/v1/domains/:domain');
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}}/v1/domains/:domain'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/:domain';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/:domain"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/:domain" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/:domain",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/v1/domains/:domain');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/:domain');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/:domain');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/:domain' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/:domain' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/v1/domains/:domain")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/:domain"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/:domain"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/:domain")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/v1/domains/:domain') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/:domain";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/v1/domains/:domainhttp DELETE {{baseUrl}}/v1/domains/:domainwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/v1/domains/:domainimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/:domain")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete all DNS Records for the specified Domain with the specified Type and Name
{{baseUrl}}/v1/domains/:domain/records/:type/:name
QUERY PARAMS
domain
type
name
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/:domain/records/:type/:name");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/v1/domains/:domain/records/:type/:name")require "http/client"
url = "{{baseUrl}}/v1/domains/:domain/records/:type/:name"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/v1/domains/:domain/records/:type/:name"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/:domain/records/:type/:name");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/:domain/records/:type/:name"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/v1/domains/:domain/records/:type/:name HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/domains/:domain/records/:type/:name")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/:domain/records/:type/:name"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/records/:type/:name")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/v1/domains/:domain/records/:type/:name")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/v1/domains/:domain/records/:type/:name');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/v1/domains/:domain/records/:type/:name'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/:domain/records/:type/:name';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/:domain/records/:type/:name',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/records/:type/:name")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/:domain/records/:type/:name',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/v1/domains/:domain/records/:type/:name'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/v1/domains/:domain/records/:type/:name');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/v1/domains/:domain/records/:type/:name'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/:domain/records/:type/:name';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/:domain/records/:type/:name"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/:domain/records/:type/:name" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/:domain/records/:type/:name",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/v1/domains/:domain/records/:type/:name');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/:domain/records/:type/:name');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/:domain/records/:type/:name');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/:domain/records/:type/:name' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/:domain/records/:type/:name' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/v1/domains/:domain/records/:type/:name")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/:domain/records/:type/:name"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/:domain/records/:type/:name"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/:domain/records/:type/:name")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/v1/domains/:domain/records/:type/:name') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/:domain/records/:type/:name";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/v1/domains/:domain/records/:type/:namehttp DELETE {{baseUrl}}/v1/domains/:domain/records/:type/:namewget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/v1/domains/:domain/records/:type/:nameimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/:domain/records/:type/:name")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Determine whether or not the specified domain is available for purchase
{{baseUrl}}/v1/domains/available
QUERY PARAMS
domain
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/available?domain=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/domains/available" {:query-params {:domain ""}})require "http/client"
url = "{{baseUrl}}/v1/domains/available?domain="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/domains/available?domain="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/available?domain=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/available?domain="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/domains/available?domain= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/domains/available?domain=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/available?domain="))
.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}}/v1/domains/available?domain=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/domains/available?domain=")
.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}}/v1/domains/available?domain=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/v1/domains/available',
params: {domain: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/available?domain=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/available?domain=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/available?domain=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/available?domain=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/v1/domains/available',
qs: {domain: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/domains/available');
req.query({
domain: ''
});
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}}/v1/domains/available',
params: {domain: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/available?domain=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/available?domain="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/available?domain=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/available?domain=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/domains/available?domain=');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/available');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'domain' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/available');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'domain' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/available?domain=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/available?domain=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/domains/available?domain=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/available"
querystring = {"domain":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/available"
queryString <- list(domain = "")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/available?domain=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/domains/available') do |req|
req.params['domain'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/available";
let querystring = [
("domain", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/v1/domains/available?domain='http GET '{{baseUrl}}/v1/domains/available?domain='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/v1/domains/available?domain='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/available?domain=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Determine whether or not the specified domains are available for purchase
{{baseUrl}}/v1/domains/available
BODY json
[
{}
]
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/available");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "[\n {}\n]");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/domains/available" {:content-type :json
:form-params [{}]})require "http/client"
url = "{{baseUrl}}/v1/domains/available"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "[\n {}\n]"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/domains/available"),
Content = new StringContent("[\n {}\n]")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/available");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n {}\n]", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/available"
payload := strings.NewReader("[\n {}\n]")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/domains/available HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 8
[
{}
]AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/domains/available")
.setHeader("content-type", "application/json")
.setBody("[\n {}\n]")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/available"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("[\n {}\n]"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "[\n {}\n]");
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/domains/available")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/domains/available")
.header("content-type", "application/json")
.body("[\n {}\n]")
.asString(); const data = JSON.stringify([
{}
]);
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/v1/domains/available');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/domains/available',
headers: {'content-type': 'application/json'},
data: [{}]
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/available';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/available',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '[\n {}\n]'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "[\n {}\n]")
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/available")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/available',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify([{}]));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/domains/available',
headers: {'content-type': 'application/json'},
body: [{}],
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/domains/available');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send([
{}
]);
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}}/v1/domains/available',
headers: {'content-type': 'application/json'},
data: [{}]
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/available';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @[ @{ } ];
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/available"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/available" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n {}\n]" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/available",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
[
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/domains/available', [
'body' => '[
{}
]',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/available');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
[
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
[
]
]));
$request->setRequestUrl('{{baseUrl}}/v1/domains/available');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/available' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
{}
]'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/available' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
{}
]'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "[\n {}\n]"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/v1/domains/available", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/available"
payload = [{}]
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/available"
payload <- "[\n {}\n]"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/available")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "[\n {}\n]"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/v1/domains/available') do |req|
req.body = "[\n {}\n]"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/available";
let payload = (json!({}));
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/domains/available \
--header 'content-type: application/json' \
--data '[
{}
]'echo '[
{}
]' | \
http POST {{baseUrl}}/v1/domains/available \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '[\n {}\n]' \
--output-document \
- {{baseUrl}}/v1/domains/availableimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [[]] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/available")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Purchase and register the specified Domain
{{baseUrl}}/v1/domains/purchase
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/purchase");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/domains/purchase")require "http/client"
url = "{{baseUrl}}/v1/domains/purchase"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/domains/purchase"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/purchase");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/purchase"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/domains/purchase HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/domains/purchase")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/purchase"))
.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}}/v1/domains/purchase")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/domains/purchase")
.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}}/v1/domains/purchase');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/v1/domains/purchase'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/purchase';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/purchase',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/purchase")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/purchase',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'POST', url: '{{baseUrl}}/v1/domains/purchase'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/domains/purchase');
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}}/v1/domains/purchase'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/purchase';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/purchase"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/purchase" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/purchase",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/domains/purchase');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/purchase');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/purchase');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/purchase' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/purchase' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/v1/domains/purchase")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/purchase"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/purchase"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/purchase")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/v1/domains/purchase') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/purchase";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/domains/purchasehttp POST {{baseUrl}}/v1/domains/purchasewget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/v1/domains/purchaseimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/purchase")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Purchase and start or restart transfer process
{{baseUrl}}/v1/domains/:domain/transfer
QUERY PARAMS
domain
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/:domain/transfer");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/domains/:domain/transfer")require "http/client"
url = "{{baseUrl}}/v1/domains/:domain/transfer"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/domains/:domain/transfer"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/:domain/transfer");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/:domain/transfer"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/domains/:domain/transfer HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/domains/:domain/transfer")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/:domain/transfer"))
.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}}/v1/domains/:domain/transfer")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/domains/:domain/transfer")
.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}}/v1/domains/:domain/transfer');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/v1/domains/:domain/transfer'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/:domain/transfer';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/:domain/transfer',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/transfer")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/:domain/transfer',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'POST', url: '{{baseUrl}}/v1/domains/:domain/transfer'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/domains/:domain/transfer');
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}}/v1/domains/:domain/transfer'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/:domain/transfer';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/:domain/transfer"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/:domain/transfer" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/:domain/transfer",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/domains/:domain/transfer');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/:domain/transfer');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/:domain/transfer');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/:domain/transfer' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/:domain/transfer' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/v1/domains/:domain/transfer")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/:domain/transfer"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/:domain/transfer"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/:domain/transfer")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/v1/domains/:domain/transfer') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/:domain/transfer";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/domains/:domain/transferhttp POST {{baseUrl}}/v1/domains/:domain/transferwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/v1/domains/:domain/transferimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/:domain/transfer")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Purchase privacy for a specified domain
{{baseUrl}}/v1/domains/:domain/privacy/purchase
QUERY PARAMS
domain
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/:domain/privacy/purchase");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/domains/:domain/privacy/purchase")require "http/client"
url = "{{baseUrl}}/v1/domains/:domain/privacy/purchase"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/domains/:domain/privacy/purchase"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/:domain/privacy/purchase");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/:domain/privacy/purchase"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/domains/:domain/privacy/purchase HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/domains/:domain/privacy/purchase")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/:domain/privacy/purchase"))
.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}}/v1/domains/:domain/privacy/purchase")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/domains/:domain/privacy/purchase")
.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}}/v1/domains/:domain/privacy/purchase');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/domains/:domain/privacy/purchase'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/:domain/privacy/purchase';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/:domain/privacy/purchase',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/privacy/purchase")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/:domain/privacy/purchase',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/domains/:domain/privacy/purchase'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/domains/:domain/privacy/purchase');
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}}/v1/domains/:domain/privacy/purchase'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/:domain/privacy/purchase';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/:domain/privacy/purchase"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/:domain/privacy/purchase" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/:domain/privacy/purchase",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/domains/:domain/privacy/purchase');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/:domain/privacy/purchase');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/:domain/privacy/purchase');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/:domain/privacy/purchase' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/:domain/privacy/purchase' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/v1/domains/:domain/privacy/purchase")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/:domain/privacy/purchase"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/:domain/privacy/purchase"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/:domain/privacy/purchase")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/v1/domains/:domain/privacy/purchase') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/:domain/privacy/purchase";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/domains/:domain/privacy/purchasehttp POST {{baseUrl}}/v1/domains/:domain/privacy/purchasewget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/v1/domains/:domain/privacy/purchaseimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/:domain/privacy/purchase")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Re-send Contact E-mail Verification for specified Domain
{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail
QUERY PARAMS
domain
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail")require "http/client"
url = "{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/domains/:domain/verifyRegistrantEmail HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail"))
.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}}/v1/domains/:domain/verifyRegistrantEmail")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail")
.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}}/v1/domains/:domain/verifyRegistrantEmail');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/:domain/verifyRegistrantEmail',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail');
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}}/v1/domains/:domain/verifyRegistrantEmail'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/v1/domains/:domain/verifyRegistrantEmail")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/v1/domains/:domain/verifyRegistrantEmail') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/domains/:domain/verifyRegistrantEmailhttp POST {{baseUrl}}/v1/domains/:domain/verifyRegistrantEmailwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/v1/domains/:domain/verifyRegistrantEmailimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/:domain/verifyRegistrantEmail")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Renew the specified Domain
{{baseUrl}}/v1/domains/:domain/renew
QUERY PARAMS
domain
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/:domain/renew");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/domains/:domain/renew")require "http/client"
url = "{{baseUrl}}/v1/domains/:domain/renew"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/domains/:domain/renew"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/:domain/renew");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/:domain/renew"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/domains/:domain/renew HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/domains/:domain/renew")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/:domain/renew"))
.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}}/v1/domains/:domain/renew")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/domains/:domain/renew")
.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}}/v1/domains/:domain/renew');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/v1/domains/:domain/renew'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/:domain/renew';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/:domain/renew',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/renew")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/:domain/renew',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'POST', url: '{{baseUrl}}/v1/domains/:domain/renew'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/domains/:domain/renew');
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}}/v1/domains/:domain/renew'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/:domain/renew';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/:domain/renew"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/:domain/renew" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/:domain/renew",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/domains/:domain/renew');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/:domain/renew');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/:domain/renew');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/:domain/renew' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/:domain/renew' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/v1/domains/:domain/renew")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/:domain/renew"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/:domain/renew"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/:domain/renew")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/v1/domains/:domain/renew') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/:domain/renew";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/domains/:domain/renewhttp POST {{baseUrl}}/v1/domains/:domain/renewwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/v1/domains/:domain/renewimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/:domain/renew")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Replace all DNS Records for the specified Domain with the specified Type and Name
{{baseUrl}}/v1/domains/:domain/records/:type/:name
QUERY PARAMS
domain
type
name
BODY json
[
{
"data": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
}
]
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/:domain/records/:type/:name");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "[\n {\n \"data\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/v1/domains/:domain/records/:type/:name" {:content-type :json
:form-params [{:data ""
:port 0
:priority 0
:protocol ""
:service ""
:ttl 0
:weight 0}]})require "http/client"
url = "{{baseUrl}}/v1/domains/:domain/records/:type/:name"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "[\n {\n \"data\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]"
response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/v1/domains/:domain/records/:type/:name"),
Content = new StringContent("[\n {\n \"data\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/:domain/records/:type/:name");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n {\n \"data\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/:domain/records/:type/:name"
payload := strings.NewReader("[\n {\n \"data\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/v1/domains/:domain/records/:type/:name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 130
[
{
"data": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
}
]AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v1/domains/:domain/records/:type/:name")
.setHeader("content-type", "application/json")
.setBody("[\n {\n \"data\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/:domain/records/:type/:name"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("[\n {\n \"data\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "[\n {\n \"data\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]");
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/records/:type/:name")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/v1/domains/:domain/records/:type/:name")
.header("content-type", "application/json")
.body("[\n {\n \"data\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]")
.asString(); const data = JSON.stringify([
{
data: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
weight: 0
}
]);
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/v1/domains/:domain/records/:type/:name');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/v1/domains/:domain/records/:type/:name',
headers: {'content-type': 'application/json'},
data: [{data: '', port: 0, priority: 0, protocol: '', service: '', ttl: 0, weight: 0}]
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/:domain/records/:type/:name';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '[{"data":"","port":0,"priority":0,"protocol":"","service":"","ttl":0,"weight":0}]'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/:domain/records/:type/:name',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '[\n {\n "data": "",\n "port": 0,\n "priority": 0,\n "protocol": "",\n "service": "",\n "ttl": 0,\n "weight": 0\n }\n]'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "[\n {\n \"data\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]")
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/records/:type/:name")
.put(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/:domain/records/:type/:name',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify([{data: '', port: 0, priority: 0, protocol: '', service: '', ttl: 0, weight: 0}]));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/v1/domains/:domain/records/:type/:name',
headers: {'content-type': 'application/json'},
body: [{data: '', port: 0, priority: 0, protocol: '', service: '', ttl: 0, weight: 0}],
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/v1/domains/:domain/records/:type/:name');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send([
{
data: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
weight: 0
}
]);
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/v1/domains/:domain/records/:type/:name',
headers: {'content-type': 'application/json'},
data: [{data: '', port: 0, priority: 0, protocol: '', service: '', ttl: 0, weight: 0}]
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/:domain/records/:type/:name';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '[{"data":"","port":0,"priority":0,"protocol":"","service":"","ttl":0,"weight":0}]'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @[ @{ @"data": @"", @"port": @0, @"priority": @0, @"protocol": @"", @"service": @"", @"ttl": @0, @"weight": @0 } ];
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/:domain/records/:type/:name"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/:domain/records/:type/:name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n {\n \"data\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/:domain/records/:type/:name",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
[
'data' => '',
'port' => 0,
'priority' => 0,
'protocol' => '',
'service' => '',
'ttl' => 0,
'weight' => 0
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/v1/domains/:domain/records/:type/:name', [
'body' => '[
{
"data": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
}
]',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/:domain/records/:type/:name');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
[
'data' => '',
'port' => 0,
'priority' => 0,
'protocol' => '',
'service' => '',
'ttl' => 0,
'weight' => 0
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
[
'data' => '',
'port' => 0,
'priority' => 0,
'protocol' => '',
'service' => '',
'ttl' => 0,
'weight' => 0
]
]));
$request->setRequestUrl('{{baseUrl}}/v1/domains/:domain/records/:type/:name');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/:domain/records/:type/:name' -Method PUT -Headers $headers -ContentType 'application/json' -Body '[
{
"data": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
}
]'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/:domain/records/:type/:name' -Method PUT -Headers $headers -ContentType 'application/json' -Body '[
{
"data": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
}
]'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "[\n {\n \"data\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/v1/domains/:domain/records/:type/:name", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/:domain/records/:type/:name"
payload = [
{
"data": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
}
]
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/:domain/records/:type/:name"
payload <- "[\n {\n \"data\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]"
encode <- "json"
response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/:domain/records/:type/:name")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "[\n {\n \"data\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/v1/domains/:domain/records/:type/:name') do |req|
req.body = "[\n {\n \"data\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/:domain/records/:type/:name";
let payload = (
json!({
"data": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
})
);
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/v1/domains/:domain/records/:type/:name \
--header 'content-type: application/json' \
--data '[
{
"data": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
}
]'echo '[
{
"data": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
}
]' | \
http PUT {{baseUrl}}/v1/domains/:domain/records/:type/:name \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '[\n {\n "data": "",\n "port": 0,\n "priority": 0,\n "protocol": "",\n "service": "",\n "ttl": 0,\n "weight": 0\n }\n]' \
--output-document \
- {{baseUrl}}/v1/domains/:domain/records/:type/:nameimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
[
"data": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
]
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/:domain/records/:type/:name")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Replace all DNS Records for the specified Domain with the specified Type
{{baseUrl}}/v1/domains/:domain/records/:type
QUERY PARAMS
domain
type
BODY json
[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
}
]
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/:domain/records/:type");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/v1/domains/:domain/records/:type" {:content-type :json
:form-params [{:data ""
:name ""
:port 0
:priority 0
:protocol ""
:service ""
:ttl 0
:weight 0}]})require "http/client"
url = "{{baseUrl}}/v1/domains/:domain/records/:type"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]"
response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/v1/domains/:domain/records/:type"),
Content = new StringContent("[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/:domain/records/:type");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/:domain/records/:type"
payload := strings.NewReader("[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/v1/domains/:domain/records/:type HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 146
[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
}
]AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v1/domains/:domain/records/:type")
.setHeader("content-type", "application/json")
.setBody("[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/:domain/records/:type"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]");
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/records/:type")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/v1/domains/:domain/records/:type")
.header("content-type", "application/json")
.body("[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]")
.asString(); const data = JSON.stringify([
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
weight: 0
}
]);
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/v1/domains/:domain/records/:type');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/v1/domains/:domain/records/:type',
headers: {'content-type': 'application/json'},
data: [
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
weight: 0
}
]
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/:domain/records/:type';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '[{"data":"","name":"","port":0,"priority":0,"protocol":"","service":"","ttl":0,"weight":0}]'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/:domain/records/:type',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '[\n {\n "data": "",\n "name": "",\n "port": 0,\n "priority": 0,\n "protocol": "",\n "service": "",\n "ttl": 0,\n "weight": 0\n }\n]'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]")
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/records/:type")
.put(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/:domain/records/:type',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify([
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
weight: 0
}
]));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/v1/domains/:domain/records/:type',
headers: {'content-type': 'application/json'},
body: [
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
weight: 0
}
],
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/v1/domains/:domain/records/:type');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send([
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
weight: 0
}
]);
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/v1/domains/:domain/records/:type',
headers: {'content-type': 'application/json'},
data: [
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
weight: 0
}
]
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/:domain/records/:type';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '[{"data":"","name":"","port":0,"priority":0,"protocol":"","service":"","ttl":0,"weight":0}]'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @[ @{ @"data": @"", @"name": @"", @"port": @0, @"priority": @0, @"protocol": @"", @"service": @"", @"ttl": @0, @"weight": @0 } ];
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/:domain/records/:type"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/:domain/records/:type" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/:domain/records/:type",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
[
'data' => '',
'name' => '',
'port' => 0,
'priority' => 0,
'protocol' => '',
'service' => '',
'ttl' => 0,
'weight' => 0
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/v1/domains/:domain/records/:type', [
'body' => '[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
}
]',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/:domain/records/:type');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
[
'data' => '',
'name' => '',
'port' => 0,
'priority' => 0,
'protocol' => '',
'service' => '',
'ttl' => 0,
'weight' => 0
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
[
'data' => '',
'name' => '',
'port' => 0,
'priority' => 0,
'protocol' => '',
'service' => '',
'ttl' => 0,
'weight' => 0
]
]));
$request->setRequestUrl('{{baseUrl}}/v1/domains/:domain/records/:type');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/:domain/records/:type' -Method PUT -Headers $headers -ContentType 'application/json' -Body '[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
}
]'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/:domain/records/:type' -Method PUT -Headers $headers -ContentType 'application/json' -Body '[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
}
]'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/v1/domains/:domain/records/:type", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/:domain/records/:type"
payload = [
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
}
]
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/:domain/records/:type"
payload <- "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]"
encode <- "json"
response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/:domain/records/:type")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/v1/domains/:domain/records/:type') do |req|
req.body = "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"weight\": 0\n }\n]"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/:domain/records/:type";
let payload = (
json!({
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
})
);
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/v1/domains/:domain/records/:type \
--header 'content-type: application/json' \
--data '[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
}
]'echo '[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
}
]' | \
http PUT {{baseUrl}}/v1/domains/:domain/records/:type \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '[\n {\n "data": "",\n "name": "",\n "port": 0,\n "priority": 0,\n "protocol": "",\n "service": "",\n "ttl": 0,\n "weight": 0\n }\n]' \
--output-document \
- {{baseUrl}}/v1/domains/:domain/records/:typeimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
[
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"weight": 0
]
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/:domain/records/:type")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Replace all DNS Records for the specified Domain
{{baseUrl}}/v1/domains/:domain/records
QUERY PARAMS
domain
BODY json
[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
}
]
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/:domain/records");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/v1/domains/:domain/records" {:content-type :json
:form-params [{:data ""
:name ""
:port 0
:priority 0
:protocol ""
:service ""
:ttl 0
:type ""
:weight 0}]})require "http/client"
url = "{{baseUrl}}/v1/domains/:domain/records"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]"
response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/v1/domains/:domain/records"),
Content = new StringContent("[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/:domain/records");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/:domain/records"
payload := strings.NewReader("[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/v1/domains/:domain/records HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 162
[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
}
]AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v1/domains/:domain/records")
.setHeader("content-type", "application/json")
.setBody("[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/:domain/records"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]");
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/records")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/v1/domains/:domain/records")
.header("content-type", "application/json")
.body("[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]")
.asString(); const data = JSON.stringify([
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
type: '',
weight: 0
}
]);
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/v1/domains/:domain/records');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/v1/domains/:domain/records',
headers: {'content-type': 'application/json'},
data: [
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
type: '',
weight: 0
}
]
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/:domain/records';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '[{"data":"","name":"","port":0,"priority":0,"protocol":"","service":"","ttl":0,"type":"","weight":0}]'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/:domain/records',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '[\n {\n "data": "",\n "name": "",\n "port": 0,\n "priority": 0,\n "protocol": "",\n "service": "",\n "ttl": 0,\n "type": "",\n "weight": 0\n }\n]'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]")
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/records")
.put(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/:domain/records',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify([
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
type: '',
weight: 0
}
]));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/v1/domains/:domain/records',
headers: {'content-type': 'application/json'},
body: [
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
type: '',
weight: 0
}
],
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/v1/domains/:domain/records');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send([
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
type: '',
weight: 0
}
]);
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/v1/domains/:domain/records',
headers: {'content-type': 'application/json'},
data: [
{
data: '',
name: '',
port: 0,
priority: 0,
protocol: '',
service: '',
ttl: 0,
type: '',
weight: 0
}
]
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/:domain/records';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '[{"data":"","name":"","port":0,"priority":0,"protocol":"","service":"","ttl":0,"type":"","weight":0}]'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @[ @{ @"data": @"", @"name": @"", @"port": @0, @"priority": @0, @"protocol": @"", @"service": @"", @"ttl": @0, @"type": @"", @"weight": @0 } ];
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/:domain/records"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/:domain/records" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/:domain/records",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
[
'data' => '',
'name' => '',
'port' => 0,
'priority' => 0,
'protocol' => '',
'service' => '',
'ttl' => 0,
'type' => '',
'weight' => 0
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/v1/domains/:domain/records', [
'body' => '[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
}
]',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/:domain/records');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
[
'data' => '',
'name' => '',
'port' => 0,
'priority' => 0,
'protocol' => '',
'service' => '',
'ttl' => 0,
'type' => '',
'weight' => 0
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
[
'data' => '',
'name' => '',
'port' => 0,
'priority' => 0,
'protocol' => '',
'service' => '',
'ttl' => 0,
'type' => '',
'weight' => 0
]
]));
$request->setRequestUrl('{{baseUrl}}/v1/domains/:domain/records');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/:domain/records' -Method PUT -Headers $headers -ContentType 'application/json' -Body '[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
}
]'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/:domain/records' -Method PUT -Headers $headers -ContentType 'application/json' -Body '[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
}
]'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/v1/domains/:domain/records", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/:domain/records"
payload = [
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
}
]
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/:domain/records"
payload <- "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]"
encode <- "json"
response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/:domain/records")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/v1/domains/:domain/records') do |req|
req.body = "[\n {\n \"data\": \"\",\n \"name\": \"\",\n \"port\": 0,\n \"priority\": 0,\n \"protocol\": \"\",\n \"service\": \"\",\n \"ttl\": 0,\n \"type\": \"\",\n \"weight\": 0\n }\n]"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/:domain/records";
let payload = (
json!({
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
})
);
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/v1/domains/:domain/records \
--header 'content-type: application/json' \
--data '[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
}
]'echo '[
{
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
}
]' | \
http PUT {{baseUrl}}/v1/domains/:domain/records \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '[\n {\n "data": "",\n "name": "",\n "port": 0,\n "priority": 0,\n "protocol": "",\n "service": "",\n "ttl": 0,\n "type": "",\n "weight": 0\n }\n]' \
--output-document \
- {{baseUrl}}/v1/domains/:domain/recordsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
[
"data": "",
"name": "",
"port": 0,
"priority": 0,
"protocol": "",
"service": "",
"ttl": 0,
"type": "",
"weight": 0
]
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/:domain/records")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve DNS Records for the specified Domain, optionally with the specified Type and-or Name
{{baseUrl}}/v1/domains/:domain/records/:type/:name
QUERY PARAMS
domain
type
name
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/:domain/records/:type/:name");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/domains/:domain/records/:type/:name")require "http/client"
url = "{{baseUrl}}/v1/domains/:domain/records/:type/:name"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/domains/:domain/records/:type/:name"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/:domain/records/:type/:name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/:domain/records/:type/:name"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/domains/:domain/records/:type/:name HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/domains/:domain/records/:type/:name")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/:domain/records/:type/:name"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/records/:type/:name")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/domains/:domain/records/:type/:name")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v1/domains/:domain/records/:type/:name');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/v1/domains/:domain/records/:type/:name'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/:domain/records/:type/:name';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/:domain/records/:type/:name',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/records/:type/:name")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/:domain/records/:type/:name',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/v1/domains/:domain/records/:type/:name'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/domains/:domain/records/:type/:name');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/v1/domains/:domain/records/:type/:name'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/:domain/records/:type/:name';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/:domain/records/:type/:name"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/:domain/records/:type/:name" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/:domain/records/:type/:name",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/domains/:domain/records/:type/:name');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/:domain/records/:type/:name');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/:domain/records/:type/:name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/:domain/records/:type/:name' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/:domain/records/:type/:name' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/domains/:domain/records/:type/:name")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/:domain/records/:type/:name"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/:domain/records/:type/:name"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/:domain/records/:type/:name")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/domains/:domain/records/:type/:name') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/:domain/records/:type/:name";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/domains/:domain/records/:type/:namehttp GET {{baseUrl}}/v1/domains/:domain/records/:type/:namewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/domains/:domain/records/:type/:nameimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/:domain/records/:type/:name")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve a list of Domains for the specified Shopper
{{baseUrl}}/v1/domains
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/domains")require "http/client"
url = "{{baseUrl}}/v1/domains"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/domains"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/domains HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/domains")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains"))
.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}}/v1/domains")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/domains")
.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}}/v1/domains');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v1/domains'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v1/domains'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/domains');
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}}/v1/domains'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/domains');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/domains")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/domains') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/domainshttp GET {{baseUrl}}/v1/domainswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/domainsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve details for the specified Domain
{{baseUrl}}/v1/domains/:domain
QUERY PARAMS
domain
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/:domain");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/domains/:domain")require "http/client"
url = "{{baseUrl}}/v1/domains/:domain"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/domains/:domain"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/:domain");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/:domain"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/domains/:domain HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/domains/:domain")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/:domain"))
.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}}/v1/domains/:domain")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/domains/:domain")
.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}}/v1/domains/:domain');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v1/domains/:domain'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/:domain';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/:domain',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/:domain',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v1/domains/:domain'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/domains/:domain');
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}}/v1/domains/:domain'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/:domain';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/:domain"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/:domain" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/:domain",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/domains/:domain');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/:domain');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/:domain');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/:domain' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/:domain' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/domains/:domain")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/:domain"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/:domain"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/:domain")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/domains/:domain') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/:domain";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/domains/:domainhttp GET {{baseUrl}}/v1/domains/:domainwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/domains/:domainimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/:domain")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve the legal agreement(s) required to purchase the specified TLD and add-ons
{{baseUrl}}/v1/domains/agreements
QUERY PARAMS
tlds
privacy
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/agreements?tlds=&privacy=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/domains/agreements" {:query-params {:tlds ""
:privacy ""}})require "http/client"
url = "{{baseUrl}}/v1/domains/agreements?tlds=&privacy="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/domains/agreements?tlds=&privacy="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/agreements?tlds=&privacy=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/agreements?tlds=&privacy="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/domains/agreements?tlds=&privacy= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/domains/agreements?tlds=&privacy=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/agreements?tlds=&privacy="))
.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}}/v1/domains/agreements?tlds=&privacy=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/domains/agreements?tlds=&privacy=")
.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}}/v1/domains/agreements?tlds=&privacy=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/v1/domains/agreements',
params: {tlds: '', privacy: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/agreements?tlds=&privacy=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/agreements?tlds=&privacy=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/agreements?tlds=&privacy=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/agreements?tlds=&privacy=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/v1/domains/agreements',
qs: {tlds: '', privacy: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/domains/agreements');
req.query({
tlds: '',
privacy: ''
});
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}}/v1/domains/agreements',
params: {tlds: '', privacy: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/agreements?tlds=&privacy=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/agreements?tlds=&privacy="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/agreements?tlds=&privacy=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/agreements?tlds=&privacy=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/domains/agreements?tlds=&privacy=');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/agreements');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'tlds' => '',
'privacy' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/agreements');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'tlds' => '',
'privacy' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/agreements?tlds=&privacy=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/agreements?tlds=&privacy=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/domains/agreements?tlds=&privacy=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/agreements"
querystring = {"tlds":"","privacy":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/agreements"
queryString <- list(
tlds = "",
privacy = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/agreements?tlds=&privacy=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/domains/agreements') do |req|
req.params['tlds'] = ''
req.params['privacy'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/agreements";
let querystring = [
("tlds", ""),
("privacy", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/v1/domains/agreements?tlds=&privacy='http GET '{{baseUrl}}/v1/domains/agreements?tlds=&privacy='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/v1/domains/agreements?tlds=&privacy='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/agreements?tlds=&privacy=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve the schema to be submitted when registering a Domain for the specified TLD
{{baseUrl}}/v1/domains/purchase/schema/:tld
QUERY PARAMS
tld
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/purchase/schema/:tld");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/domains/purchase/schema/:tld")require "http/client"
url = "{{baseUrl}}/v1/domains/purchase/schema/:tld"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/domains/purchase/schema/:tld"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/purchase/schema/:tld");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/purchase/schema/:tld"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/domains/purchase/schema/:tld HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/domains/purchase/schema/:tld")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/purchase/schema/:tld"))
.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}}/v1/domains/purchase/schema/:tld")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/domains/purchase/schema/:tld")
.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}}/v1/domains/purchase/schema/:tld');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/v1/domains/purchase/schema/:tld'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/purchase/schema/:tld';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/purchase/schema/:tld',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/purchase/schema/:tld")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/purchase/schema/:tld',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/v1/domains/purchase/schema/:tld'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/domains/purchase/schema/:tld');
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}}/v1/domains/purchase/schema/:tld'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/purchase/schema/:tld';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/purchase/schema/:tld"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/purchase/schema/:tld" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/purchase/schema/:tld",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/domains/purchase/schema/:tld');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/purchase/schema/:tld');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/purchase/schema/:tld');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/purchase/schema/:tld' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/purchase/schema/:tld' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/domains/purchase/schema/:tld")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/purchase/schema/:tld"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/purchase/schema/:tld"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/purchase/schema/:tld")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/domains/purchase/schema/:tld') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/purchase/schema/:tld";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/domains/purchase/schema/:tldhttp GET {{baseUrl}}/v1/domains/purchase/schema/:tldwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/domains/purchase/schema/:tldimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/purchase/schema/:tld")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieves a list of TLDs supported and enabled for sale
{{baseUrl}}/v1/domains/tlds
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/tlds");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/domains/tlds")require "http/client"
url = "{{baseUrl}}/v1/domains/tlds"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/domains/tlds"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/tlds");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/tlds"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/domains/tlds HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/domains/tlds")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/tlds"))
.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}}/v1/domains/tlds")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/domains/tlds")
.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}}/v1/domains/tlds');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v1/domains/tlds'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/tlds';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/tlds',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/tlds")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/tlds',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v1/domains/tlds'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/domains/tlds');
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}}/v1/domains/tlds'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/tlds';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/tlds"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/tlds" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/tlds",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/domains/tlds');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/tlds');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/tlds');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/tlds' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/tlds' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/domains/tlds")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/tlds"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/tlds"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/tlds")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/domains/tlds') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/tlds";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/domains/tldshttp GET {{baseUrl}}/v1/domains/tldswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/domains/tldsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/tlds")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Submit a privacy cancellation request for the given domain
{{baseUrl}}/v1/domains/:domain/privacy
QUERY PARAMS
domain
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/:domain/privacy");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/v1/domains/:domain/privacy")require "http/client"
url = "{{baseUrl}}/v1/domains/:domain/privacy"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/v1/domains/:domain/privacy"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/:domain/privacy");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/:domain/privacy"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/v1/domains/:domain/privacy HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/domains/:domain/privacy")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/:domain/privacy"))
.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}}/v1/domains/:domain/privacy")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/v1/domains/:domain/privacy")
.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}}/v1/domains/:domain/privacy');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/v1/domains/:domain/privacy'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/:domain/privacy';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/:domain/privacy',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/privacy")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/:domain/privacy',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/v1/domains/:domain/privacy'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/v1/domains/:domain/privacy');
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}}/v1/domains/:domain/privacy'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/:domain/privacy';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/:domain/privacy"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/:domain/privacy" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/:domain/privacy",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/v1/domains/:domain/privacy');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/:domain/privacy');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/:domain/privacy');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/:domain/privacy' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/:domain/privacy' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/v1/domains/:domain/privacy")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/:domain/privacy"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/:domain/privacy"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/:domain/privacy")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/v1/domains/:domain/privacy') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/:domain/privacy";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/v1/domains/:domain/privacyhttp DELETE {{baseUrl}}/v1/domains/:domain/privacywget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/v1/domains/:domain/privacyimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/:domain/privacy")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Suggest alternate Domain names based on a seed Domain, a set of keywords, or the shopper's purchase history
{{baseUrl}}/v1/domains/suggest
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/suggest");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/domains/suggest")require "http/client"
url = "{{baseUrl}}/v1/domains/suggest"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/domains/suggest"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/suggest");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/suggest"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/domains/suggest HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/domains/suggest")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/suggest"))
.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}}/v1/domains/suggest")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/domains/suggest")
.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}}/v1/domains/suggest');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v1/domains/suggest'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/suggest';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/suggest',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/suggest")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/suggest',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v1/domains/suggest'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/domains/suggest');
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}}/v1/domains/suggest'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/suggest';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/suggest"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/suggest" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/suggest",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/domains/suggest');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/suggest');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/suggest');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/suggest' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/suggest' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/domains/suggest")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/suggest"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/suggest"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/suggest")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/domains/suggest') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/suggest";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/domains/suggesthttp GET {{baseUrl}}/v1/domains/suggestwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/domains/suggestimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/suggest")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update details for the specified Domain
{{baseUrl}}/v1/domains/:domain
QUERY PARAMS
domain
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/:domain");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/v1/domains/:domain")require "http/client"
url = "{{baseUrl}}/v1/domains/:domain"
response = HTTP::Client.patch url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/v1/domains/:domain"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/:domain");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/:domain"
req, _ := http.NewRequest("PATCH", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/v1/domains/:domain HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1/domains/:domain")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/:domain"))
.method("PATCH", 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}}/v1/domains/:domain")
.patch(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/v1/domains/:domain")
.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('PATCH', '{{baseUrl}}/v1/domains/:domain');
xhr.send(data);import axios from 'axios';
const options = {method: 'PATCH', url: '{{baseUrl}}/v1/domains/:domain'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/:domain';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/:domain',
method: 'PATCH',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain")
.patch(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/:domain',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'PATCH', url: '{{baseUrl}}/v1/domains/:domain'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/v1/domains/:domain');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PATCH', url: '{{baseUrl}}/v1/domains/:domain'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/:domain';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/:domain"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/:domain" in
Client.call `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/:domain",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/v1/domains/:domain');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/:domain');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/:domain');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/:domain' -Method PATCH $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/:domain' -Method PATCH import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PATCH", "/baseUrl/v1/domains/:domain")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/:domain"
response = requests.patch(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/:domain"
response <- VERB("PATCH", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/:domain")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.patch('/baseUrl/v1/domains/:domain') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/:domain";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/v1/domains/:domainhttp PATCH {{baseUrl}}/v1/domains/:domainwget --quiet \
--method PATCH \
--output-document \
- {{baseUrl}}/v1/domains/:domainimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/:domain")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update domain
{{baseUrl}}/v1/domains/:domain/contacts
QUERY PARAMS
domain
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/:domain/contacts");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/v1/domains/:domain/contacts")require "http/client"
url = "{{baseUrl}}/v1/domains/:domain/contacts"
response = HTTP::Client.patch url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/v1/domains/:domain/contacts"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/:domain/contacts");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/:domain/contacts"
req, _ := http.NewRequest("PATCH", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/v1/domains/:domain/contacts HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1/domains/:domain/contacts")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/:domain/contacts"))
.method("PATCH", 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}}/v1/domains/:domain/contacts")
.patch(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/v1/domains/:domain/contacts")
.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('PATCH', '{{baseUrl}}/v1/domains/:domain/contacts');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/v1/domains/:domain/contacts'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/:domain/contacts';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/:domain/contacts',
method: 'PATCH',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/:domain/contacts")
.patch(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/:domain/contacts',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/v1/domains/:domain/contacts'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/v1/domains/:domain/contacts');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/v1/domains/:domain/contacts'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/:domain/contacts';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/:domain/contacts"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/:domain/contacts" in
Client.call `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/:domain/contacts",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/v1/domains/:domain/contacts');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/:domain/contacts');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/:domain/contacts');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/:domain/contacts' -Method PATCH $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/:domain/contacts' -Method PATCH import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PATCH", "/baseUrl/v1/domains/:domain/contacts")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/:domain/contacts"
response = requests.patch(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/:domain/contacts"
response <- VERB("PATCH", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/:domain/contacts")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.patch('/baseUrl/v1/domains/:domain/contacts') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/:domain/contacts";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/v1/domains/:domain/contactshttp PATCH {{baseUrl}}/v1/domains/:domain/contactswget --quiet \
--method PATCH \
--output-document \
- {{baseUrl}}/v1/domains/:domain/contactsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/:domain/contacts")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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
Validate the request body using the Domain Contact Validation Schema for specified domains.
{{baseUrl}}/v1/domains/contacts/validate
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/contacts/validate");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/domains/contacts/validate")require "http/client"
url = "{{baseUrl}}/v1/domains/contacts/validate"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/domains/contacts/validate"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/contacts/validate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/contacts/validate"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/domains/contacts/validate HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/domains/contacts/validate")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/contacts/validate"))
.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}}/v1/domains/contacts/validate")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/domains/contacts/validate")
.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}}/v1/domains/contacts/validate');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/domains/contacts/validate'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/contacts/validate';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/contacts/validate',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/contacts/validate")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/contacts/validate',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/domains/contacts/validate'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/domains/contacts/validate');
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}}/v1/domains/contacts/validate'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/contacts/validate';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/contacts/validate"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/contacts/validate" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/contacts/validate",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/domains/contacts/validate');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/contacts/validate');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/contacts/validate');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/contacts/validate' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/contacts/validate' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/v1/domains/contacts/validate")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/contacts/validate"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/contacts/validate"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/contacts/validate")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/v1/domains/contacts/validate') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/contacts/validate";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/domains/contacts/validatehttp POST {{baseUrl}}/v1/domains/contacts/validatewget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/v1/domains/contacts/validateimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/contacts/validate")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Validate the request body using the Domain Purchase Schema for the specified TLD
{{baseUrl}}/v1/domains/purchase/validate
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/domains/purchase/validate");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/domains/purchase/validate")require "http/client"
url = "{{baseUrl}}/v1/domains/purchase/validate"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/domains/purchase/validate"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/domains/purchase/validate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/domains/purchase/validate"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/domains/purchase/validate HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/domains/purchase/validate")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/domains/purchase/validate"))
.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}}/v1/domains/purchase/validate")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/domains/purchase/validate")
.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}}/v1/domains/purchase/validate');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/domains/purchase/validate'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/domains/purchase/validate';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/domains/purchase/validate',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/domains/purchase/validate")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/domains/purchase/validate',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/domains/purchase/validate'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/domains/purchase/validate');
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}}/v1/domains/purchase/validate'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/domains/purchase/validate';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/domains/purchase/validate"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/domains/purchase/validate" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/domains/purchase/validate",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/domains/purchase/validate');
echo $response->getBody();setUrl('{{baseUrl}}/v1/domains/purchase/validate');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/domains/purchase/validate');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/domains/purchase/validate' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/domains/purchase/validate' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/v1/domains/purchase/validate")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/domains/purchase/validate"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/domains/purchase/validate"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/domains/purchase/validate")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/v1/domains/purchase/validate') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/domains/purchase/validate";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/domains/purchase/validatehttp POST {{baseUrl}}/v1/domains/purchase/validatewget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/v1/domains/purchase/validateimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/domains/purchase/validate")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()