KYC API Documentation

POST Creates a new notification

{{baseUrl}}/api/v1/company/notification/register/:id

HEADERS

user_key

QUERY PARAMS

BODY formUrlEncoded

callbackUrl

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/notification/register/:id");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "callbackUrl=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/v1/company/notification/register/:id" {:headers {:user_key "{{apiKey}}"}
                                                                                     :form-params {:callbackUrl ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/notification/register/:id"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "callbackUrl="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/notification/register/:id"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "callbackUrl", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/notification/register/:id");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "callbackUrl=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/notification/register/:id"

	payload := strings.NewReader("callbackUrl=")

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

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

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

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

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

}

POST /baseUrl/api/v1/company/notification/register/:id HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 12

callbackUrl=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/company/notification/register/:id")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("callbackUrl=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/notification/register/:id"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("callbackUrl="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "callbackUrl=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/notification/register/:id")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/company/notification/register/:id")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("callbackUrl=")
  .asString();

const data = 'callbackUrl=';

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

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

xhr.open('POST', '{{baseUrl}}/api/v1/company/notification/register/:id');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('callbackUrl', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/notification/register/:id',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/api/v1/company/notification/register/:id';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({callbackUrl: ''})
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/notification/register/:id',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    callbackUrl: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "callbackUrl=")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/notification/register/:id")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

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

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/notification/register/:id',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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

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

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

req.write(qs.stringify({callbackUrl: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/notification/register/:id',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  form: {callbackUrl: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/company/notification/register/:id');

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

req.form({
  callbackUrl: ''
});

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

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

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

const encodedParams = new URLSearchParams();
encodedParams.set('callbackUrl', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/notification/register/:id',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

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

const encodedParams = new URLSearchParams();
encodedParams.set('callbackUrl', '');

const url = '{{baseUrl}}/api/v1/company/notification/register/:id';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

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

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"callbackUrl=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/notification/register/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/notification/register/:id" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "callbackUrl=" in

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

 "{{baseUrl}}/api/v1/company/notification/register/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "callbackUrl=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/v1/company/notification/register/:id', [
  'form_params' => [
    'callbackUrl' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/notification/register/:id');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'callbackUrl' => ''
]);

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

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

append(new http\QueryString([
  'callbackUrl' => ''
]));

$request->setRequestUrl('{{baseUrl}}/api/v1/company/notification/register/:id');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/notification/register/:id' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'callbackUrl='

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/notification/register/:id' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'callbackUrl='

import http.client

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

payload = "callbackUrl="

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

conn.request("POST", "/baseUrl/api/v1/company/notification/register/:id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/notification/register/:id"

payload = { "callbackUrl": "" }
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/notification/register/:id"

payload <- "callbackUrl="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/notification/register/:id")

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

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "callbackUrl="

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

require 'faraday'

data = {
  :callbackUrl => "",
}

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

response = conn.post('/baseUrl/api/v1/company/notification/register/:id') do |req|
  req.headers['user_key'] = '{{apiKey}}'
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/notification/register/:id";

    let payload = json!({"callbackUrl": ""});

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/company/notification/register/:id \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}' \
  --data callbackUrl=

http --form POST {{baseUrl}}/api/v1/company/notification/register/:id \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}' \
  callbackUrl=''

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data callbackUrl= \
  --output-document \
  - {{baseUrl}}/api/v1/company/notification/register/:id

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "callbackUrl=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/notification/register/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST Deactivates an active notification

{{baseUrl}}/api/v1/company/monitoring/unregister/:id

HEADERS

user_key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/monitoring/unregister/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/v1/company/monitoring/unregister/:id" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/monitoring/unregister/:id"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/monitoring/unregister/:id"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/monitoring/unregister/:id");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/monitoring/unregister/:id"

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

	req.Header.Add("user_key", "{{apiKey}}")

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

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

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

}

POST /baseUrl/api/v1/company/monitoring/unregister/:id HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/company/monitoring/unregister/:id")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/monitoring/unregister/:id"))
    .header("user_key", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/monitoring/unregister/:id")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/company/monitoring/unregister/:id")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/api/v1/company/monitoring/unregister/:id');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/monitoring/unregister/:id',
  headers: {user_key: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/v1/company/monitoring/unregister/:id';
const options = {method: 'POST', headers: {user_key: '{{apiKey}}'}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/monitoring/unregister/:id',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/monitoring/unregister/:id")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/monitoring/unregister/:id',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/monitoring/unregister/:id',
  headers: {user_key: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/company/monitoring/unregister/:id');

req.headers({
  user_key: '{{apiKey}}'
});

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

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

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/monitoring/unregister/:id',
  headers: {user_key: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/v1/company/monitoring/unregister/:id';
const options = {method: 'POST', headers: {user_key: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/monitoring/unregister/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/monitoring/unregister/:id" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

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

 "{{baseUrl}}/api/v1/company/monitoring/unregister/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/v1/company/monitoring/unregister/:id', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/monitoring/unregister/:id');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/v1/company/monitoring/unregister/:id');
$request->setRequestMethod('POST');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/monitoring/unregister/:id' -Method POST -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/monitoring/unregister/:id' -Method POST -Headers $headers

import http.client

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

headers = { 'user_key': "{{apiKey}}" }

conn.request("POST", "/baseUrl/api/v1/company/monitoring/unregister/:id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/monitoring/unregister/:id"

headers = {"user_key": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/monitoring/unregister/:id"

response <- VERB("POST", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/monitoring/unregister/:id")

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

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.post('/baseUrl/api/v1/company/monitoring/unregister/:id') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/monitoring/unregister/:id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/company/monitoring/unregister/:id \
  --header 'user_key: {{apiKey}}'

http POST {{baseUrl}}/api/v1/company/monitoring/unregister/:id \
  user_key:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/company/monitoring/unregister/:id

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/monitoring/unregister/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Get available ChangeTypes

{{baseUrl}}/api/v1/company/monitoring/changeTypes

HEADERS

user_key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/monitoring/changeTypes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/company/monitoring/changeTypes" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/monitoring/changeTypes"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/monitoring/changeTypes"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/monitoring/changeTypes");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/monitoring/changeTypes"

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

	req.Header.Add("user_key", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/v1/company/monitoring/changeTypes HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/company/monitoring/changeTypes")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/monitoring/changeTypes"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/monitoring/changeTypes")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/company/monitoring/changeTypes")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/company/monitoring/changeTypes');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/monitoring/changeTypes',
  headers: {user_key: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/v1/company/monitoring/changeTypes';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/monitoring/changeTypes',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/monitoring/changeTypes")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/monitoring/changeTypes',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/monitoring/changeTypes',
  headers: {user_key: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/company/monitoring/changeTypes');

req.headers({
  user_key: '{{apiKey}}'
});

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

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/monitoring/changeTypes',
  headers: {user_key: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/v1/company/monitoring/changeTypes';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/monitoring/changeTypes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/monitoring/changeTypes" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

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

 "{{baseUrl}}/api/v1/company/monitoring/changeTypes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/v1/company/monitoring/changeTypes', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/monitoring/changeTypes');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/v1/company/monitoring/changeTypes');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/monitoring/changeTypes' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/monitoring/changeTypes' -Method GET -Headers $headers

import http.client

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

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/company/monitoring/changeTypes", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/monitoring/changeTypes"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/monitoring/changeTypes"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/monitoring/changeTypes")

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

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/v1/company/monitoring/changeTypes') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/monitoring/changeTypes";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/company/monitoring/changeTypes \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/company/monitoring/changeTypes \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/company/monitoring/changeTypes

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/monitoring/changeTypes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Get monitor status for specific company id

{{baseUrl}}/api/v1/company/monitoring/list/:id

HEADERS

user_key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/monitoring/list/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/company/monitoring/list/:id" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/monitoring/list/:id"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/monitoring/list/:id"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/monitoring/list/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/monitoring/list/:id"

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

	req.Header.Add("user_key", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/v1/company/monitoring/list/:id HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/company/monitoring/list/:id")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/monitoring/list/:id"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/monitoring/list/:id")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/company/monitoring/list/:id")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/company/monitoring/list/:id');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/monitoring/list/:id',
  headers: {user_key: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/v1/company/monitoring/list/:id';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/monitoring/list/:id',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/monitoring/list/:id")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/monitoring/list/:id',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/monitoring/list/:id',
  headers: {user_key: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/company/monitoring/list/:id');

req.headers({
  user_key: '{{apiKey}}'
});

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

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/monitoring/list/:id',
  headers: {user_key: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/v1/company/monitoring/list/:id';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/monitoring/list/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/monitoring/list/:id" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

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

 "{{baseUrl}}/api/v1/company/monitoring/list/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/v1/company/monitoring/list/:id', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/monitoring/list/:id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/v1/company/monitoring/list/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/monitoring/list/:id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/monitoring/list/:id' -Method GET -Headers $headers

import http.client

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

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/company/monitoring/list/:id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/monitoring/list/:id"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/monitoring/list/:id"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/monitoring/list/:id")

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

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/v1/company/monitoring/list/:id') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/monitoring/list/:id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/company/monitoring/list/:id \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/company/monitoring/list/:id \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/company/monitoring/list/:id

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/monitoring/list/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

POST Register a Company for monitoring

{{baseUrl}}/api/v1/company/monitoring/register/:id

HEADERS

user_key

QUERY PARAMS

BODY formUrlEncoded

callbackUrl

changeType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/monitoring/register/:id");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "callbackUrl=&changeType=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/v1/company/monitoring/register/:id" {:headers {:user_key "{{apiKey}}"}
                                                                                   :form-params {:callbackUrl ""
                                                                                                 :changeType ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/monitoring/register/:id"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "callbackUrl=&changeType="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/monitoring/register/:id"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "callbackUrl", "" },
        { "changeType", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/monitoring/register/:id");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "callbackUrl=&changeType=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/monitoring/register/:id"

	payload := strings.NewReader("callbackUrl=&changeType=")

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

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

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

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

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

}

POST /baseUrl/api/v1/company/monitoring/register/:id HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 24

callbackUrl=&changeType=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/company/monitoring/register/:id")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("callbackUrl=&changeType=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/monitoring/register/:id"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("callbackUrl=&changeType="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "callbackUrl=&changeType=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/monitoring/register/:id")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/company/monitoring/register/:id")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("callbackUrl=&changeType=")
  .asString();

const data = 'callbackUrl=&changeType=';

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

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

xhr.open('POST', '{{baseUrl}}/api/v1/company/monitoring/register/:id');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('callbackUrl', '');
encodedParams.set('changeType', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/monitoring/register/:id',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/api/v1/company/monitoring/register/:id';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({callbackUrl: '', changeType: ''})
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/monitoring/register/:id',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    callbackUrl: '',
    changeType: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "callbackUrl=&changeType=")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/monitoring/register/:id")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

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

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/monitoring/register/:id',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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

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

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

req.write(qs.stringify({callbackUrl: '', changeType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/monitoring/register/:id',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  form: {callbackUrl: '', changeType: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/company/monitoring/register/:id');

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

req.form({
  callbackUrl: '',
  changeType: ''
});

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

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

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

const encodedParams = new URLSearchParams();
encodedParams.set('callbackUrl', '');
encodedParams.set('changeType', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/monitoring/register/:id',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

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

const encodedParams = new URLSearchParams();
encodedParams.set('callbackUrl', '');
encodedParams.set('changeType', '');

const url = '{{baseUrl}}/api/v1/company/monitoring/register/:id';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

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

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"callbackUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&changeType=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/monitoring/register/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/monitoring/register/:id" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "callbackUrl=&changeType=" in

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

 "{{baseUrl}}/api/v1/company/monitoring/register/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "callbackUrl=&changeType=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/v1/company/monitoring/register/:id', [
  'form_params' => [
    'callbackUrl' => '',
    'changeType' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/monitoring/register/:id');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'callbackUrl' => '',
  'changeType' => ''
]);

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

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

append(new http\QueryString([
  'callbackUrl' => '',
  'changeType' => ''
]));

$request->setRequestUrl('{{baseUrl}}/api/v1/company/monitoring/register/:id');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/monitoring/register/:id' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'callbackUrl=&changeType='

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/monitoring/register/:id' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'callbackUrl=&changeType='

import http.client

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

payload = "callbackUrl=&changeType="

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

conn.request("POST", "/baseUrl/api/v1/company/monitoring/register/:id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/monitoring/register/:id"

payload = {
    "callbackUrl": "",
    "changeType": ""
}
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/monitoring/register/:id"

payload <- "callbackUrl=&changeType="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/monitoring/register/:id")

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

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "callbackUrl=&changeType="

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

require 'faraday'

data = {
  :callbackUrl => "",
  :changeType => "",
}

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

response = conn.post('/baseUrl/api/v1/company/monitoring/register/:id') do |req|
  req.headers['user_key'] = '{{apiKey}}'
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/monitoring/register/:id";

    let payload = json!({
        "callbackUrl": "",
        "changeType": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/company/monitoring/register/:id \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}' \
  --data callbackUrl= \
  --data changeType=

http --form POST {{baseUrl}}/api/v1/company/monitoring/register/:id \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}' \
  callbackUrl='' \
  changeType=''

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'callbackUrl=&changeType=' \
  --output-document \
  - {{baseUrl}}/api/v1/company/monitoring/register/:id

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "callbackUrl=".data(using: String.Encoding.utf8)!)
postData.append("&changeType=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/monitoring/register/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

GET Retrieves a list of companies from the KYC API company index (GET)

{{baseUrl}}/api/v1/company/search/number/:country/:number

HEADERS

user_key

QUERY PARAMS

country

number

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/search/number/:country/:number");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/company/search/number/:country/:number" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/search/number/:country/:number"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/search/number/:country/:number"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/search/number/:country/:number");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/search/number/:country/:number"

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

	req.Header.Add("user_key", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/v1/company/search/number/:country/:number HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/company/search/number/:country/:number")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/search/number/:country/:number"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/search/number/:country/:number")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/company/search/number/:country/:number")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/company/search/number/:country/:number');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/search/number/:country/:number',
  headers: {user_key: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/v1/company/search/number/:country/:number';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/search/number/:country/:number',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/search/number/:country/:number")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/search/number/:country/:number',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/search/number/:country/:number',
  headers: {user_key: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/company/search/number/:country/:number');

req.headers({
  user_key: '{{apiKey}}'
});

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

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/search/number/:country/:number',
  headers: {user_key: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/v1/company/search/number/:country/:number';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/search/number/:country/:number"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/search/number/:country/:number" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

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

 "{{baseUrl}}/api/v1/company/search/number/:country/:number",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/v1/company/search/number/:country/:number', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/search/number/:country/:number');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/v1/company/search/number/:country/:number');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/search/number/:country/:number' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/search/number/:country/:number' -Method GET -Headers $headers

import http.client

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

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/company/search/number/:country/:number", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/search/number/:country/:number"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/search/number/:country/:number"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/search/number/:country/:number")

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

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/v1/company/search/number/:country/:number') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/search/number/:country/:number";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/company/search/number/:country/:number \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/company/search/number/:country/:number \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/company/search/number/:country/:number

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/search/number/:country/:number")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

POST Retrieves a list of companies from the KYC API company index (POST)

{{baseUrl}}/api/v1/company/search/:country

HEADERS

user_key

QUERY PARAMS

country

BODY formUrlEncoded

address

name

number

phone

url

vat

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/search/:country");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "address=&name=&number=&phone=&url=&vat=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/v1/company/search/:country" {:headers {:user_key "{{apiKey}}"}
                                                                           :form-params {:address ""
                                                                                         :name ""
                                                                                         :number ""
                                                                                         :phone ""
                                                                                         :url ""
                                                                                         :vat ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/search/:country"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "address=&name=&number=&phone=&url=&vat="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/search/:country"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "address", "" },
        { "name", "" },
        { "number", "" },
        { "phone", "" },
        { "url", "" },
        { "vat", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/search/:country");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "address=&name=&number=&phone=&url=&vat=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/search/:country"

	payload := strings.NewReader("address=&name=&number=&phone=&url=&vat=")

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

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

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

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

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

}

POST /baseUrl/api/v1/company/search/:country HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 39

address=&name=&number=&phone=&url=&vat=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/company/search/:country")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("address=&name=&number=&phone=&url=&vat=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/search/:country"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("address=&name=&number=&phone=&url=&vat="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "address=&name=&number=&phone=&url=&vat=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/search/:country")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/company/search/:country")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("address=&name=&number=&phone=&url=&vat=")
  .asString();

const data = 'address=&name=&number=&phone=&url=&vat=';

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

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

xhr.open('POST', '{{baseUrl}}/api/v1/company/search/:country');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('address', '');
encodedParams.set('name', '');
encodedParams.set('number', '');
encodedParams.set('phone', '');
encodedParams.set('url', '');
encodedParams.set('vat', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/search/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/api/v1/company/search/:country';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({address: '', name: '', number: '', phone: '', url: '', vat: ''})
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/search/:country',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    address: '',
    name: '',
    number: '',
    phone: '',
    url: '',
    vat: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "address=&name=&number=&phone=&url=&vat=")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/search/:country")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

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

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/search/:country',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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

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

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

req.write(qs.stringify({address: '', name: '', number: '', phone: '', url: '', vat: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/search/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  form: {address: '', name: '', number: '', phone: '', url: '', vat: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/company/search/:country');

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

req.form({
  address: '',
  name: '',
  number: '',
  phone: '',
  url: '',
  vat: ''
});

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

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

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

const encodedParams = new URLSearchParams();
encodedParams.set('address', '');
encodedParams.set('name', '');
encodedParams.set('number', '');
encodedParams.set('phone', '');
encodedParams.set('url', '');
encodedParams.set('vat', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/search/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

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

const encodedParams = new URLSearchParams();
encodedParams.set('address', '');
encodedParams.set('name', '');
encodedParams.set('number', '');
encodedParams.set('phone', '');
encodedParams.set('url', '');
encodedParams.set('vat', '');

const url = '{{baseUrl}}/api/v1/company/search/:country';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

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

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"address=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&number=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&phone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&vat=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/search/:country"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/search/:country" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "address=&name=&number=&phone=&url=&vat=" in

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

 "{{baseUrl}}/api/v1/company/search/:country",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "address=&name=&number=&phone=&url=&vat=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/v1/company/search/:country', [
  'form_params' => [
    'address' => '',
    'name' => '',
    'number' => '',
    'phone' => '',
    'url' => '',
    'vat' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/search/:country');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'address' => '',
  'name' => '',
  'number' => '',
  'phone' => '',
  'url' => '',
  'vat' => ''
]);

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

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

append(new http\QueryString([
  'address' => '',
  'name' => '',
  'number' => '',
  'phone' => '',
  'url' => '',
  'vat' => ''
]));

$request->setRequestUrl('{{baseUrl}}/api/v1/company/search/:country');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/search/:country' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'address=&name=&number=&phone=&url=&vat='

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/search/:country' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'address=&name=&number=&phone=&url=&vat='

import http.client

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

payload = "address=&name=&number=&phone=&url=&vat="

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

conn.request("POST", "/baseUrl/api/v1/company/search/:country", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/search/:country"

payload = {
    "address": "",
    "name": "",
    "number": "",
    "phone": "",
    "url": "",
    "vat": ""
}
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/search/:country"

payload <- "address=&name=&number=&phone=&url=&vat="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/search/:country")

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

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "address=&name=&number=&phone=&url=&vat="

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

require 'faraday'

data = {
  :address => "",
  :name => "",
  :number => "",
  :phone => "",
  :url => "",
  :vat => "",
}

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

response = conn.post('/baseUrl/api/v1/company/search/:country') do |req|
  req.headers['user_key'] = '{{apiKey}}'
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/search/:country";

    let payload = json!({
        "address": "",
        "name": "",
        "number": "",
        "phone": "",
        "url": "",
        "vat": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/company/search/:country \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}' \
  --data address= \
  --data name= \
  --data number= \
  --data phone= \
  --data url= \
  --data vat=

http --form POST {{baseUrl}}/api/v1/company/search/:country \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}' \
  address='' \
  name='' \
  number='' \
  phone='' \
  url='' \
  vat=''

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'address=&name=&number=&phone=&url=&vat=' \
  --output-document \
  - {{baseUrl}}/api/v1/company/search/:country

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "address=".data(using: String.Encoding.utf8)!)
postData.append("&name=".data(using: String.Encoding.utf8)!)
postData.append("&number=".data(using: String.Encoding.utf8)!)
postData.append("&phone=".data(using: String.Encoding.utf8)!)
postData.append("&url=".data(using: String.Encoding.utf8)!)
postData.append("&vat=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/search/:country")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

GET Retrieves a list of companies from the KYC API company index

{{baseUrl}}/api/v1/company/search/name/:country/:name

HEADERS

user_key

QUERY PARAMS

country

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/search/name/:country/:name");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/company/search/name/:country/:name" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/search/name/:country/:name"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/search/name/:country/:name"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/search/name/:country/:name");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/search/name/:country/:name"

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

	req.Header.Add("user_key", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/v1/company/search/name/:country/:name HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/company/search/name/:country/:name")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/search/name/:country/:name"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/search/name/:country/:name")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/company/search/name/:country/:name")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/company/search/name/:country/:name');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/search/name/:country/:name',
  headers: {user_key: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/v1/company/search/name/:country/:name';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/search/name/:country/:name',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/search/name/:country/:name")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/search/name/:country/:name',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/search/name/:country/:name',
  headers: {user_key: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/company/search/name/:country/:name');

req.headers({
  user_key: '{{apiKey}}'
});

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

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/search/name/:country/:name',
  headers: {user_key: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/v1/company/search/name/:country/:name';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/search/name/:country/:name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/search/name/:country/:name" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

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

 "{{baseUrl}}/api/v1/company/search/name/:country/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/v1/company/search/name/:country/:name', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/search/name/:country/:name');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/v1/company/search/name/:country/:name');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/search/name/:country/:name' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/search/name/:country/:name' -Method GET -Headers $headers

import http.client

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

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/company/search/name/:country/:name", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/search/name/:country/:name"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/search/name/:country/:name"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/search/name/:country/:name")

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

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/v1/company/search/name/:country/:name') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/search/name/:country/:name";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/company/search/name/:country/:name \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/company/search/name/:country/:name \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/company/search/name/:country/:name

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/search/name/:country/:name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Retrieves a list of companies from the official business register (GET)

{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number

HEADERS

user_key

QUERY PARAMS

country

number

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number"

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

	req.Header.Add("user_key", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/v1/company/deepsearch/number/:country/:number HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number',
  headers: {user_key: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/deepsearch/number/:country/:number',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number',
  headers: {user_key: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number');

req.headers({
  user_key: '{{apiKey}}'
});

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

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number',
  headers: {user_key: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

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

 "{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number' -Method GET -Headers $headers

import http.client

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

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/company/deepsearch/number/:country/:number", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number")

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

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/v1/company/deepsearch/number/:country/:number') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/company/deepsearch/number/:country/:number \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/company/deepsearch/number/:country/:number \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/company/deepsearch/number/:country/:number

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/deepsearch/number/:country/:number")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Retrieves a list of companies from the official business register

{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name

HEADERS

user_key

QUERY PARAMS

country

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name"

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

	req.Header.Add("user_key", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/v1/company/deepsearch/name/:country/:name HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name',
  headers: {user_key: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/deepsearch/name/:country/:name',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name',
  headers: {user_key: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name');

req.headers({
  user_key: '{{apiKey}}'
});

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

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name',
  headers: {user_key: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

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

 "{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name' -Method GET -Headers $headers

import http.client

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

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/company/deepsearch/name/:country/:name", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name")

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

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/v1/company/deepsearch/name/:country/:name') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/company/deepsearch/name/:country/:name \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/company/deepsearch/name/:country/:name \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/company/deepsearch/name/:country/:name

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/deepsearch/name/:country/:name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Retrieves a list of companies

{{baseUrl}}/api/v1/company/deepsearch/lei/:number

HEADERS

user_key

QUERY PARAMS

number

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/deepsearch/lei/:number");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/company/deepsearch/lei/:number" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/deepsearch/lei/:number"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/deepsearch/lei/:number"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/deepsearch/lei/:number");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/deepsearch/lei/:number"

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

	req.Header.Add("user_key", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/v1/company/deepsearch/lei/:number HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/company/deepsearch/lei/:number")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/deepsearch/lei/:number"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/deepsearch/lei/:number")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/company/deepsearch/lei/:number")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/company/deepsearch/lei/:number');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/deepsearch/lei/:number',
  headers: {user_key: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/v1/company/deepsearch/lei/:number';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/deepsearch/lei/:number',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/deepsearch/lei/:number")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/deepsearch/lei/:number',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/deepsearch/lei/:number',
  headers: {user_key: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/company/deepsearch/lei/:number');

req.headers({
  user_key: '{{apiKey}}'
});

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

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/deepsearch/lei/:number',
  headers: {user_key: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/v1/company/deepsearch/lei/:number';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/deepsearch/lei/:number"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/deepsearch/lei/:number" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

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

 "{{baseUrl}}/api/v1/company/deepsearch/lei/:number",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/v1/company/deepsearch/lei/:number', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/deepsearch/lei/:number');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/v1/company/deepsearch/lei/:number');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/deepsearch/lei/:number' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/deepsearch/lei/:number' -Method GET -Headers $headers

import http.client

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

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/company/deepsearch/lei/:number", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/deepsearch/lei/:number"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/deepsearch/lei/:number"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/deepsearch/lei/:number")

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

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/v1/company/deepsearch/lei/:number') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/deepsearch/lei/:number";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/company/deepsearch/lei/:number \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/company/deepsearch/lei/:number \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/company/deepsearch/lei/:number

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/deepsearch/lei/:number")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Retrieves a list of registered monitors

{{baseUrl}}/api/v1/company/monitoring/list

HEADERS

user_key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/monitoring/list");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/company/monitoring/list" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/monitoring/list"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/monitoring/list"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/monitoring/list");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/monitoring/list"

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

	req.Header.Add("user_key", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/v1/company/monitoring/list HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/company/monitoring/list")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/monitoring/list"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/monitoring/list")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/company/monitoring/list")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/company/monitoring/list');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/monitoring/list',
  headers: {user_key: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/v1/company/monitoring/list';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/monitoring/list',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/monitoring/list")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/monitoring/list',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/monitoring/list',
  headers: {user_key: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/company/monitoring/list');

req.headers({
  user_key: '{{apiKey}}'
});

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

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/monitoring/list',
  headers: {user_key: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/v1/company/monitoring/list';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/monitoring/list"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/monitoring/list" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

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

 "{{baseUrl}}/api/v1/company/monitoring/list",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/v1/company/monitoring/list', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/monitoring/list');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/v1/company/monitoring/list');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/monitoring/list' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/monitoring/list' -Method GET -Headers $headers

import http.client

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

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/company/monitoring/list", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/monitoring/list"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/monitoring/list"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/monitoring/list")

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

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/v1/company/monitoring/list') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/monitoring/list";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/company/monitoring/list \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/company/monitoring/list \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/company/monitoring/list

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/monitoring/list")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Retrieves a list of registered notifications (GET)

{{baseUrl}}/api/v1/company/notification/list/:id

HEADERS

user_key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/notification/list/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/company/notification/list/:id" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/notification/list/:id"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/notification/list/:id"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/notification/list/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/notification/list/:id"

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

	req.Header.Add("user_key", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/v1/company/notification/list/:id HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/company/notification/list/:id")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/notification/list/:id"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/notification/list/:id")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/company/notification/list/:id")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/company/notification/list/:id');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/notification/list/:id',
  headers: {user_key: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/v1/company/notification/list/:id';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/notification/list/:id',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/notification/list/:id")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/notification/list/:id',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/notification/list/:id',
  headers: {user_key: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/company/notification/list/:id');

req.headers({
  user_key: '{{apiKey}}'
});

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

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/notification/list/:id',
  headers: {user_key: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/v1/company/notification/list/:id';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/notification/list/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/notification/list/:id" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

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

 "{{baseUrl}}/api/v1/company/notification/list/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/v1/company/notification/list/:id', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/notification/list/:id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/v1/company/notification/list/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/notification/list/:id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/notification/list/:id' -Method GET -Headers $headers

import http.client

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

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/company/notification/list/:id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/notification/list/:id"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/notification/list/:id"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/notification/list/:id")

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

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/v1/company/notification/list/:id') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/notification/list/:id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/company/notification/list/:id \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/company/notification/list/:id \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/company/notification/list/:id

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/notification/list/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Retrieves a list of registered notifications

{{baseUrl}}/api/v1/company/notification/list

HEADERS

user_key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/notification/list");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/company/notification/list" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/notification/list"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/notification/list"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/notification/list");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/notification/list"

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

	req.Header.Add("user_key", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/v1/company/notification/list HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/company/notification/list")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/notification/list"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/notification/list")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/company/notification/list")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/company/notification/list');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/notification/list',
  headers: {user_key: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/v1/company/notification/list';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/notification/list',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/notification/list")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/notification/list',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/notification/list',
  headers: {user_key: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/company/notification/list');

req.headers({
  user_key: '{{apiKey}}'
});

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

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/notification/list',
  headers: {user_key: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/v1/company/notification/list';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/notification/list"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/notification/list" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

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

 "{{baseUrl}}/api/v1/company/notification/list",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/v1/company/notification/list', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/notification/list');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/v1/company/notification/list');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/notification/list' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/notification/list' -Method GET -Headers $headers

import http.client

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

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/company/notification/list", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/notification/list"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/notification/list"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/notification/list")

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

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/v1/company/notification/list') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/notification/list";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/company/notification/list \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/company/notification/list \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/company/notification/list

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/notification/list")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

POST Retrieves a list of stock exchange listings

{{baseUrl}}/api/v1/company/deepsearch/isin

HEADERS

user_key

BODY formUrlEncoded

isin

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/deepsearch/isin");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "isin=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/v1/company/deepsearch/isin" {:headers {:user_key "{{apiKey}}"}
                                                                           :form-params {:isin ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/deepsearch/isin"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "isin="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/deepsearch/isin"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "isin", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/deepsearch/isin");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "isin=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/deepsearch/isin"

	payload := strings.NewReader("isin=")

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

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

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

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

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

}

POST /baseUrl/api/v1/company/deepsearch/isin HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 5

isin=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/company/deepsearch/isin")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("isin=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/deepsearch/isin"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("isin="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "isin=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/deepsearch/isin")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/company/deepsearch/isin")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("isin=")
  .asString();

const data = 'isin=';

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

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

xhr.open('POST', '{{baseUrl}}/api/v1/company/deepsearch/isin');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('isin', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/deepsearch/isin',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/api/v1/company/deepsearch/isin';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({isin: ''})
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/deepsearch/isin',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    isin: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "isin=")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/deepsearch/isin")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

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

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/deepsearch/isin',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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

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

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

req.write(qs.stringify({isin: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/deepsearch/isin',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  form: {isin: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/company/deepsearch/isin');

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

req.form({
  isin: ''
});

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

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

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

const encodedParams = new URLSearchParams();
encodedParams.set('isin', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/deepsearch/isin',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

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

const encodedParams = new URLSearchParams();
encodedParams.set('isin', '');

const url = '{{baseUrl}}/api/v1/company/deepsearch/isin';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

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

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"isin=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/deepsearch/isin"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/deepsearch/isin" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "isin=" in

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

 "{{baseUrl}}/api/v1/company/deepsearch/isin",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "isin=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/v1/company/deepsearch/isin', [
  'form_params' => [
    'isin' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/deepsearch/isin');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'isin' => ''
]);

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

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

append(new http\QueryString([
  'isin' => ''
]));

$request->setRequestUrl('{{baseUrl}}/api/v1/company/deepsearch/isin');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/deepsearch/isin' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'isin='

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/deepsearch/isin' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'isin='

import http.client

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

payload = "isin="

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

conn.request("POST", "/baseUrl/api/v1/company/deepsearch/isin", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/deepsearch/isin"

payload = { "isin": "" }
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/deepsearch/isin"

payload <- "isin="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/deepsearch/isin")

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

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "isin="

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

require 'faraday'

data = {
  :isin => "",
}

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

response = conn.post('/baseUrl/api/v1/company/deepsearch/isin') do |req|
  req.headers['user_key'] = '{{apiKey}}'
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/deepsearch/isin";

    let payload = json!({"isin": ""});

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/company/deepsearch/isin \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}' \
  --data isin=

http --form POST {{baseUrl}}/api/v1/company/deepsearch/isin \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}' \
  isin=''

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data isin= \
  --output-document \
  - {{baseUrl}}/api/v1/company/deepsearch/isin

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "isin=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/deepsearch/isin")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

GET Retrieves announcement data

{{baseUrl}}/api/v1/company/announcement/:id

HEADERS

user_key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/announcement/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/company/announcement/:id" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/announcement/:id"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

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

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

var client = new RestClient("{{baseUrl}}/api/v1/company/announcement/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/announcement/:id"

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

	req.Header.Add("user_key", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/v1/company/announcement/:id HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/company/announcement/:id")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/announcement/:id"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/announcement/:id")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/company/announcement/:id")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/company/announcement/:id');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/announcement/:id',
  headers: {user_key: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/v1/company/announcement/:id';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/announcement/:id',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/announcement/:id")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/announcement/:id',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/announcement/:id',
  headers: {user_key: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/company/announcement/:id');

req.headers({
  user_key: '{{apiKey}}'
});

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

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/announcement/:id',
  headers: {user_key: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/v1/company/announcement/:id';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/announcement/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/announcement/:id" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

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

 "{{baseUrl}}/api/v1/company/announcement/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/v1/company/announcement/:id', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/announcement/:id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/v1/company/announcement/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/announcement/:id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/announcement/:id' -Method GET -Headers $headers

import http.client

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

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/company/announcement/:id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/announcement/:id"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/announcement/:id"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/announcement/:id")

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

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/v1/company/announcement/:id') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/announcement/:id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/company/announcement/:id \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/company/announcement/:id \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/company/announcement/:id

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/announcement/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Retrieves company announcements

{{baseUrl}}/api/v1/company/:id/announcements

HEADERS

user_key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/:id/announcements");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/company/:id/announcements" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/:id/announcements"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

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

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

var client = new RestClient("{{baseUrl}}/api/v1/company/:id/announcements");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/:id/announcements"

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

	req.Header.Add("user_key", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/v1/company/:id/announcements HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/company/:id/announcements")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/:id/announcements"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/:id/announcements")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/company/:id/announcements")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/company/:id/announcements');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/:id/announcements',
  headers: {user_key: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/v1/company/:id/announcements';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/:id/announcements',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/:id/announcements")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/:id/announcements',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/:id/announcements',
  headers: {user_key: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/company/:id/announcements');

req.headers({
  user_key: '{{apiKey}}'
});

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

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/:id/announcements',
  headers: {user_key: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/v1/company/:id/announcements';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/:id/announcements"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/:id/announcements" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

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

 "{{baseUrl}}/api/v1/company/:id/announcements",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/v1/company/:id/announcements', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/:id/announcements');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/v1/company/:id/announcements');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/:id/announcements' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/:id/announcements' -Method GET -Headers $headers

import http.client

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

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/company/:id/announcements", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/:id/announcements"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/:id/announcements"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/:id/announcements")

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

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/v1/company/:id/announcements') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/:id/announcements";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/company/:id/announcements \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/company/:id/announcements \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/company/:id/announcements

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/:id/announcements")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Retrieves company details

{{baseUrl}}/api/v1/company/:id/:dataset

HEADERS

user_key

QUERY PARAMS

dataset

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/:id/:dataset");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/company/:id/:dataset" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/:id/:dataset"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

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

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

var client = new RestClient("{{baseUrl}}/api/v1/company/:id/:dataset");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/:id/:dataset"

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

	req.Header.Add("user_key", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/v1/company/:id/:dataset HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/company/:id/:dataset")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/:id/:dataset"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/:id/:dataset")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/company/:id/:dataset")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/company/:id/:dataset');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/:id/:dataset',
  headers: {user_key: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/v1/company/:id/:dataset';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/:id/:dataset',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/:id/:dataset")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/:id/:dataset',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/:id/:dataset',
  headers: {user_key: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/company/:id/:dataset');

req.headers({
  user_key: '{{apiKey}}'
});

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

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/:id/:dataset',
  headers: {user_key: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/v1/company/:id/:dataset';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/:id/:dataset"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/:id/:dataset" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

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

 "{{baseUrl}}/api/v1/company/:id/:dataset",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/v1/company/:id/:dataset', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/:id/:dataset');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/v1/company/:id/:dataset');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/:id/:dataset' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/:id/:dataset' -Method GET -Headers $headers

import http.client

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

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/company/:id/:dataset", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/:id/:dataset"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/:id/:dataset"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/:id/:dataset")

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

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/v1/company/:id/:dataset') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/:id/:dataset";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/company/:id/:dataset \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/company/:id/:dataset \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/company/:id/:dataset

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/:id/:dataset")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Retrieves structured data extracted from a company document

{{baseUrl}}/api/v1/company/:id/super/:country

HEADERS

user_key

QUERY PARAMS

country

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/:id/super/:country");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/company/:id/super/:country" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/:id/super/:country"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/:id/super/:country"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/:id/super/:country");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/:id/super/:country"

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

	req.Header.Add("user_key", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/v1/company/:id/super/:country HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/company/:id/super/:country")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/:id/super/:country"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/:id/super/:country")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/company/:id/super/:country")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/company/:id/super/:country');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/:id/super/:country',
  headers: {user_key: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/v1/company/:id/super/:country';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/:id/super/:country',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/:id/super/:country")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/:id/super/:country',
  headers: {
    user_key: '{{apiKey}}'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/:id/super/:country',
  headers: {user_key: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/company/:id/super/:country');

req.headers({
  user_key: '{{apiKey}}'
});

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

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/company/:id/super/:country',
  headers: {user_key: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/v1/company/:id/super/:country';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/:id/super/:country"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/:id/super/:country" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

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

 "{{baseUrl}}/api/v1/company/:id/super/:country",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/v1/company/:id/super/:country', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/:id/super/:country');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/v1/company/:id/super/:country');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/:id/super/:country' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/:id/super/:country' -Method GET -Headers $headers

import http.client

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

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/company/:id/super/:country", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/company/:id/super/:country"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/:id/super/:country"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/:id/super/:country")

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

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/v1/company/:id/super/:country') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/:id/super/:country";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/company/:id/super/:country \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/company/:id/super/:country \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/company/:id/super/:country

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/:id/super/:country")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

POST Unregister a company from Monitoring

{{baseUrl}}/api/v1/company/notification/unregister/:id

HEADERS

user_key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/company/notification/unregister/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/v1/company/notification/unregister/:id" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/company/notification/unregister/:id"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/company/notification/unregister/:id"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/company/notification/unregister/:id");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/company/notification/unregister/:id"

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

	req.Header.Add("user_key", "{{apiKey}}")

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

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

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

}

POST /baseUrl/api/v1/company/notification/unregister/:id HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/company/notification/unregister/:id")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/company/notification/unregister/:id"))
    .header("user_key", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/company/notification/unregister/:id")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/company/notification/unregister/:id")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/api/v1/company/notification/unregister/:id');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/notification/unregister/:id',
  headers: {user_key: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/v1/company/notification/unregister/:id';
const options = {method: 'POST', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/company/notification/unregister/:id',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/company/notification/unregister/:id")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/company/notification/unregister/:id',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/notification/unregister/:id',
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/company/notification/unregister/:id');

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/company/notification/unregister/:id',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/company/notification/unregister/:id';
const options = {method: 'POST', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/company/notification/unregister/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/company/notification/unregister/:id" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/company/notification/unregister/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/company/notification/unregister/:id', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/company/notification/unregister/:id');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/company/notification/unregister/:id');
$request->setRequestMethod('POST');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/company/notification/unregister/:id' -Method POST -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/company/notification/unregister/:id' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("POST", "/baseUrl/api/v1/company/notification/unregister/:id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/company/notification/unregister/:id"

headers = {"user_key": "{{apiKey}}"}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/company/notification/unregister/:id"

response <- VERB("POST", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/company/notification/unregister/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/v1/company/notification/unregister/:id') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/company/notification/unregister/:id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/company/notification/unregister/:id \
  --header 'user_key: {{apiKey}}'

http POST {{baseUrl}}/api/v1/company/notification/unregister/:id \
  user_key:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/company/notification/unregister/:id

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/company/notification/unregister/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Retrieves a list of EIN numbers

{{baseUrl}}/api/v1/ein-verification/lookup

HEADERS

user_key

QUERY PARAMS

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/ein-verification/lookup?name=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/ein-verification/lookup" {:headers {:user_key "{{apiKey}}"}
                                                                          :query-params {:name ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/ein-verification/lookup?name="
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/ein-verification/lookup?name="),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/ein-verification/lookup?name=");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/ein-verification/lookup?name="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/ein-verification/lookup?name= HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/ein-verification/lookup?name=")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/ein-verification/lookup?name="))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/ein-verification/lookup?name=")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/ein-verification/lookup?name=")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/ein-verification/lookup?name=');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/ein-verification/lookup',
  params: {name: ''},
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/ein-verification/lookup?name=';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/ein-verification/lookup?name=',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/ein-verification/lookup?name=")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/ein-verification/lookup?name=',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/ein-verification/lookup',
  qs: {name: ''},
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/ein-verification/lookup');

req.query({
  name: ''
});

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/ein-verification/lookup',
  params: {name: ''},
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/ein-verification/lookup?name=';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/ein-verification/lookup?name="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/ein-verification/lookup?name=" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/ein-verification/lookup?name=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/ein-verification/lookup?name=', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/ein-verification/lookup');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'name' => ''
]);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/ein-verification/lookup');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'name' => ''
]));

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/ein-verification/lookup?name=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/ein-verification/lookup?name=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/ein-verification/lookup?name=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/ein-verification/lookup"

querystring = {"name":""}

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/ein-verification/lookup"

queryString <- list(name = "")

response <- VERB("GET", url, query = queryString, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/ein-verification/lookup?name=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/ein-verification/lookup') do |req|
  req.headers['user_key'] = '{{apiKey}}'
  req.params['name'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/ein-verification/lookup";

    let querystring = [
        ("name", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/v1/ein-verification/lookup?name=' \
  --header 'user_key: {{apiKey}}'

http GET '{{baseUrl}}/api/v1/ein-verification/lookup?name=' \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/api/v1/ein-verification/lookup?name='

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/ein-verification/lookup?name=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Verifies EIN number and retrieves company data

{{baseUrl}}/api/v1/ein-verification/comprehensive-check

HEADERS

user_key

QUERY PARAMS

ein

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/ein-verification/comprehensive-check" {:headers {:user_key "{{apiKey}}"}
                                                                                       :query-params {:ein ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein="
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein="),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/ein-verification/comprehensive-check?ein= HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein="))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/ein-verification/comprehensive-check',
  params: {ein: ''},
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/ein-verification/comprehensive-check?ein=',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/ein-verification/comprehensive-check',
  qs: {ein: ''},
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/ein-verification/comprehensive-check');

req.query({
  ein: ''
});

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/ein-verification/comprehensive-check',
  params: {ein: ''},
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/ein-verification/comprehensive-check');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'ein' => ''
]);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/ein-verification/comprehensive-check');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'ein' => ''
]));

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/ein-verification/comprehensive-check?ein=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/ein-verification/comprehensive-check"

querystring = {"ein":""}

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/ein-verification/comprehensive-check"

queryString <- list(ein = "")

response <- VERB("GET", url, query = queryString, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/ein-verification/comprehensive-check') do |req|
  req.headers['user_key'] = '{{apiKey}}'
  req.params['ein'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/ein-verification/comprehensive-check";

    let querystring = [
        ("ein", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=' \
  --header 'user_key: {{apiKey}}'

http GET '{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=' \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein='

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/ein-verification/comprehensive-check?ein=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Verifies an EIN number

{{baseUrl}}/api/v1/ein-verification/basic-check

HEADERS

user_key

QUERY PARAMS

ein

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/ein-verification/basic-check?ein=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/ein-verification/basic-check" {:headers {:user_key "{{apiKey}}"}
                                                                               :query-params {:ein ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/ein-verification/basic-check?ein="
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/ein-verification/basic-check?ein="),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/ein-verification/basic-check?ein=");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/ein-verification/basic-check?ein="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/ein-verification/basic-check?ein= HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/ein-verification/basic-check?ein=")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/ein-verification/basic-check?ein="))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/ein-verification/basic-check?ein=")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/ein-verification/basic-check?ein=")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/ein-verification/basic-check?ein=');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/ein-verification/basic-check',
  params: {ein: ''},
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/ein-verification/basic-check?ein=';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/ein-verification/basic-check?ein=',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/ein-verification/basic-check?ein=")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/ein-verification/basic-check?ein=',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/ein-verification/basic-check',
  qs: {ein: ''},
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/ein-verification/basic-check');

req.query({
  ein: ''
});

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/ein-verification/basic-check',
  params: {ein: ''},
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/ein-verification/basic-check?ein=';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/ein-verification/basic-check?ein="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/ein-verification/basic-check?ein=" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/ein-verification/basic-check?ein=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/ein-verification/basic-check?ein=', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/ein-verification/basic-check');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'ein' => ''
]);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/ein-verification/basic-check');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'ein' => ''
]));

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/ein-verification/basic-check?ein=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/ein-verification/basic-check?ein=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/ein-verification/basic-check?ein=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/ein-verification/basic-check"

querystring = {"ein":""}

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/ein-verification/basic-check"

queryString <- list(ein = "")

response <- VERB("GET", url, query = queryString, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/ein-verification/basic-check?ein=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/ein-verification/basic-check') do |req|
  req.headers['user_key'] = '{{apiKey}}'
  req.params['ein'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/ein-verification/basic-check";

    let querystring = [
        ("ein", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/v1/ein-verification/basic-check?ein=' \
  --header 'user_key: {{apiKey}}'

http GET '{{baseUrl}}/api/v1/ein-verification/basic-check?ein=' \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/api/v1/ein-verification/basic-check?ein='

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/ein-verification/basic-check?ein=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Checks validity of an IBAN number (POST)

{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban

HEADERS

user_key

BODY formUrlEncoded

ibanNumber

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban" {:headers {:user_key "{{apiKey}}"
                                                                                                        :content-type "application/x-www-form-urlencoded"}})

require "http/client"

url = "{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/iban-verification/comprehensive-check-iban HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/iban-verification/comprehensive-check-iban',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban');

req.headers({
  user_key: '{{apiKey}}',
  'content-type': 'application/x-www-form-urlencoded'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban');
$request->setRequestMethod('POST');
$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban' -Method POST -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

headers = {
    'user_key': "{{apiKey}}",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/api/v1/iban-verification/comprehensive-check-iban", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban"

payload = ""
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban"

payload <- ""

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/api/v1/iban-verification/comprehensive-check-iban') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}'

http POST {{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/iban-verification/comprehensive-check-iban")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Checks validity of an IBAN number

{{baseUrl}}/api/v1/iban-verification/check-iban

HEADERS

user_key

BODY formUrlEncoded

ibanNumber

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/iban-verification/check-iban");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/iban-verification/check-iban" {:headers {:user_key "{{apiKey}}"
                                                                                          :content-type "application/x-www-form-urlencoded"}})

require "http/client"

url = "{{baseUrl}}/api/v1/iban-verification/check-iban"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/iban-verification/check-iban"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/iban-verification/check-iban");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/iban-verification/check-iban"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/iban-verification/check-iban HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/iban-verification/check-iban")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/iban-verification/check-iban"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/iban-verification/check-iban")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/iban-verification/check-iban")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/iban-verification/check-iban');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/iban-verification/check-iban',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/iban-verification/check-iban';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/iban-verification/check-iban',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/iban-verification/check-iban")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/iban-verification/check-iban',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/iban-verification/check-iban',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/iban-verification/check-iban');

req.headers({
  user_key: '{{apiKey}}',
  'content-type': 'application/x-www-form-urlencoded'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/iban-verification/check-iban',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/iban-verification/check-iban';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/iban-verification/check-iban"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/iban-verification/check-iban" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/iban-verification/check-iban",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/iban-verification/check-iban', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/iban-verification/check-iban');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/iban-verification/check-iban');
$request->setRequestMethod('POST');
$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/iban-verification/check-iban' -Method POST -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/iban-verification/check-iban' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

headers = {
    'user_key': "{{apiKey}}",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/api/v1/iban-verification/check-iban", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/iban-verification/check-iban"

payload = ""
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/iban-verification/check-iban"

payload <- ""

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/iban-verification/check-iban")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/api/v1/iban-verification/check-iban') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/iban-verification/check-iban";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/iban-verification/check-iban \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}'

http POST {{baseUrl}}/api/v1/iban-verification/check-iban \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/api/v1/iban-verification/check-iban

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/iban-verification/check-iban")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Verifies a NIF number and retrieves company data

{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country

HEADERS

user_key

QUERY PARAMS

country

BODY formUrlEncoded

companyAddress

companyName

nifNumber

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "companyAddress=&companyName=&nifNumber=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country" {:headers {:user_key "{{apiKey}}"}
                                                                                                 :form-params {:companyAddress ""
                                                                                                               :companyName ""
                                                                                                               :nifNumber ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "companyAddress=&companyName=&nifNumber="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "companyAddress", "" },
        { "companyName", "" },
        { "nifNumber", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "companyAddress=&companyName=&nifNumber=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country"

	payload := strings.NewReader("companyAddress=&companyName=&nifNumber=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("user_key", "{{apiKey}}")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/nif-verification/comprehensive-check/:country HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 39

companyAddress=&companyName=&nifNumber=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("companyAddress=&companyName=&nifNumber=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("companyAddress=&companyName=&nifNumber="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "companyAddress=&companyName=&nifNumber=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("companyAddress=&companyName=&nifNumber=")
  .asString();

const data = 'companyAddress=&companyName=&nifNumber=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('companyAddress', '');
encodedParams.set('companyName', '');
encodedParams.set('nifNumber', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({companyAddress: '', companyName: '', nifNumber: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    companyAddress: '',
    companyName: '',
    nifNumber: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "companyAddress=&companyName=&nifNumber=")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/nif-verification/comprehensive-check/:country',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({companyAddress: '', companyName: '', nifNumber: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  form: {companyAddress: '', companyName: '', nifNumber: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country');

req.headers({
  user_key: '{{apiKey}}',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  companyAddress: '',
  companyName: '',
  nifNumber: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('companyAddress', '');
encodedParams.set('companyName', '');
encodedParams.set('nifNumber', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('companyAddress', '');
encodedParams.set('companyName', '');
encodedParams.set('nifNumber', '');

const url = '{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"companyAddress=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&companyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&nifNumber=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "companyAddress=&companyName=&nifNumber=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "companyAddress=&companyName=&nifNumber=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country', [
  'form_params' => [
    'companyAddress' => '',
    'companyName' => '',
    'nifNumber' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'companyAddress' => '',
  'companyName' => '',
  'nifNumber' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'companyAddress' => '',
  'companyName' => '',
  'nifNumber' => ''
]));

$request->setRequestUrl('{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'companyAddress=&companyName=&nifNumber='

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'companyAddress=&companyName=&nifNumber='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "companyAddress=&companyName=&nifNumber="

headers = {
    'user_key': "{{apiKey}}",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/api/v1/nif-verification/comprehensive-check/:country", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country"

payload = {
    "companyAddress": "",
    "companyName": "",
    "nifNumber": ""
}
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country"

payload <- "companyAddress=&companyName=&nifNumber="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "companyAddress=&companyName=&nifNumber="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :companyAddress => "",
  :companyName => "",
  :nifNumber => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/api/v1/nif-verification/comprehensive-check/:country') do |req|
  req.headers['user_key'] = '{{apiKey}}'
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country";

    let payload = json!({
        "companyAddress": "",
        "companyName": "",
        "nifNumber": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}' \
  --data companyAddress= \
  --data companyName= \
  --data nifNumber=

http --form POST {{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}' \
  companyAddress='' \
  companyName='' \
  nifNumber=''

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'companyAddress=&companyName=&nifNumber=' \
  --output-document \
  - {{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "companyAddress=".data(using: String.Encoding.utf8)!)
postData.append("&companyName=".data(using: String.Encoding.utf8)!)
postData.append("&nifNumber=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/nif-verification/comprehensive-check/:country")! 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 Verifies a NIF number

{{baseUrl}}/api/v1/nif-verification/basic-check/:country

HEADERS

user_key

QUERY PARAMS

country

BODY formUrlEncoded

companyAddress

companyName

nifNumber

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/nif-verification/basic-check/:country");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "companyAddress=&companyName=&nifNumber=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/nif-verification/basic-check/:country" {:headers {:user_key "{{apiKey}}"}
                                                                                         :form-params {:companyAddress ""
                                                                                                       :companyName ""
                                                                                                       :nifNumber ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/nif-verification/basic-check/:country"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "companyAddress=&companyName=&nifNumber="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/nif-verification/basic-check/:country"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "companyAddress", "" },
        { "companyName", "" },
        { "nifNumber", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/nif-verification/basic-check/:country");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "companyAddress=&companyName=&nifNumber=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/nif-verification/basic-check/:country"

	payload := strings.NewReader("companyAddress=&companyName=&nifNumber=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("user_key", "{{apiKey}}")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/nif-verification/basic-check/:country HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 39

companyAddress=&companyName=&nifNumber=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/nif-verification/basic-check/:country")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("companyAddress=&companyName=&nifNumber=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/nif-verification/basic-check/:country"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("companyAddress=&companyName=&nifNumber="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "companyAddress=&companyName=&nifNumber=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/nif-verification/basic-check/:country")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/nif-verification/basic-check/:country")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("companyAddress=&companyName=&nifNumber=")
  .asString();

const data = 'companyAddress=&companyName=&nifNumber=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/nif-verification/basic-check/:country');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('companyAddress', '');
encodedParams.set('companyName', '');
encodedParams.set('nifNumber', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/nif-verification/basic-check/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/nif-verification/basic-check/:country';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({companyAddress: '', companyName: '', nifNumber: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/nif-verification/basic-check/:country',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    companyAddress: '',
    companyName: '',
    nifNumber: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "companyAddress=&companyName=&nifNumber=")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/nif-verification/basic-check/:country")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/nif-verification/basic-check/:country',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({companyAddress: '', companyName: '', nifNumber: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/nif-verification/basic-check/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  form: {companyAddress: '', companyName: '', nifNumber: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/nif-verification/basic-check/:country');

req.headers({
  user_key: '{{apiKey}}',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  companyAddress: '',
  companyName: '',
  nifNumber: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('companyAddress', '');
encodedParams.set('companyName', '');
encodedParams.set('nifNumber', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/nif-verification/basic-check/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('companyAddress', '');
encodedParams.set('companyName', '');
encodedParams.set('nifNumber', '');

const url = '{{baseUrl}}/api/v1/nif-verification/basic-check/:country';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"companyAddress=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&companyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&nifNumber=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/nif-verification/basic-check/:country"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/nif-verification/basic-check/:country" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "companyAddress=&companyName=&nifNumber=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/nif-verification/basic-check/:country",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "companyAddress=&companyName=&nifNumber=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/nif-verification/basic-check/:country', [
  'form_params' => [
    'companyAddress' => '',
    'companyName' => '',
    'nifNumber' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/nif-verification/basic-check/:country');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'companyAddress' => '',
  'companyName' => '',
  'nifNumber' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'companyAddress' => '',
  'companyName' => '',
  'nifNumber' => ''
]));

$request->setRequestUrl('{{baseUrl}}/api/v1/nif-verification/basic-check/:country');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/nif-verification/basic-check/:country' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'companyAddress=&companyName=&nifNumber='

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/nif-verification/basic-check/:country' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'companyAddress=&companyName=&nifNumber='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "companyAddress=&companyName=&nifNumber="

headers = {
    'user_key': "{{apiKey}}",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/api/v1/nif-verification/basic-check/:country", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/nif-verification/basic-check/:country"

payload = {
    "companyAddress": "",
    "companyName": "",
    "nifNumber": ""
}
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/nif-verification/basic-check/:country"

payload <- "companyAddress=&companyName=&nifNumber="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/nif-verification/basic-check/:country")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "companyAddress=&companyName=&nifNumber="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :companyAddress => "",
  :companyName => "",
  :nifNumber => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/api/v1/nif-verification/basic-check/:country') do |req|
  req.headers['user_key'] = '{{apiKey}}'
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/nif-verification/basic-check/:country";

    let payload = json!({
        "companyAddress": "",
        "companyName": "",
        "nifNumber": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/nif-verification/basic-check/:country \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}' \
  --data companyAddress= \
  --data companyName= \
  --data nifNumber=

http --form POST {{baseUrl}}/api/v1/nif-verification/basic-check/:country \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}' \
  companyAddress='' \
  companyName='' \
  nifNumber=''

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'companyAddress=&companyName=&nifNumber=' \
  --output-document \
  - {{baseUrl}}/api/v1/nif-verification/basic-check/:country

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "companyAddress=".data(using: String.Encoding.utf8)!)
postData.append("&companyName=".data(using: String.Encoding.utf8)!)
postData.append("&nifNumber=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/nif-verification/basic-check/:country")! 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 Deactive a pep sanction monitor

{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id

HEADERS

user_key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/pepsanction/monitor/unregister/:id HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id"))
    .header("user_key", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id';
const options = {method: 'POST', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/pepsanction/monitor/unregister/:id',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id',
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id');

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id';
const options = {method: 'POST', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id');
$request->setRequestMethod('POST');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id' -Method POST -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("POST", "/baseUrl/api/v1/pepsanction/monitor/unregister/:id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id"

headers = {"user_key": "{{apiKey}}"}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id"

response <- VERB("POST", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/v1/pepsanction/monitor/unregister/:id') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id \
  --header 'user_key: {{apiKey}}'

http POST {{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id \
  user_key:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/pepsanction/monitor/unregister/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Orders a new Pep Sanction Check Report

{{baseUrl}}/api/v1/pepsanction/order/:type/:search

HEADERS

user_key

QUERY PARAMS

type

BODY formUrlEncoded

Aliases

Country

DOB

FamilyName

Filters

GivenName

LEI

Locale

Medialists

MiddleName

Monitoring

Peplists

Region

SmartMatch

Watchlists

Webhook

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/pepsanction/order/:type/:search");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/pepsanction/order/:type/:search" {:headers {:user_key "{{apiKey}}"
                                                                                             :content-type "application/x-www-form-urlencoded"}})

require "http/client"

url = "{{baseUrl}}/api/v1/pepsanction/order/:type/:search"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/pepsanction/order/:type/:search"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/pepsanction/order/:type/:search");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/pepsanction/order/:type/:search"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/pepsanction/order/:type/:search HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/pepsanction/order/:type/:search")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/pepsanction/order/:type/:search"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/pepsanction/order/:type/:search")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/pepsanction/order/:type/:search")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/pepsanction/order/:type/:search');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/pepsanction/order/:type/:search',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/pepsanction/order/:type/:search';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/pepsanction/order/:type/:search',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/pepsanction/order/:type/:search")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/pepsanction/order/:type/:search',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/pepsanction/order/:type/:search',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/pepsanction/order/:type/:search');

req.headers({
  user_key: '{{apiKey}}',
  'content-type': 'application/x-www-form-urlencoded'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/pepsanction/order/:type/:search',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/pepsanction/order/:type/:search';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/pepsanction/order/:type/:search"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/pepsanction/order/:type/:search" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/pepsanction/order/:type/:search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/pepsanction/order/:type/:search', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/pepsanction/order/:type/:search');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/pepsanction/order/:type/:search');
$request->setRequestMethod('POST');
$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/pepsanction/order/:type/:search' -Method POST -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/pepsanction/order/:type/:search' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

headers = {
    'user_key': "{{apiKey}}",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/api/v1/pepsanction/order/:type/:search", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/pepsanction/order/:type/:search"

payload = ""
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/pepsanction/order/:type/:search"

payload <- ""

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/pepsanction/order/:type/:search")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/api/v1/pepsanction/order/:type/:search') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/pepsanction/order/:type/:search";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/pepsanction/order/:type/:search \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}'

http POST {{baseUrl}}/api/v1/pepsanction/order/:type/:search \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/api/v1/pepsanction/order/:type/:search

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/pepsanction/order/:type/:search")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Retrieves a list of monitor entries

{{baseUrl}}/api/v1/pepsanction/monitor/list

HEADERS

user_key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/pepsanction/monitor/list");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/pepsanction/monitor/list" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/pepsanction/monitor/list"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/pepsanction/monitor/list"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/pepsanction/monitor/list");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/pepsanction/monitor/list"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/pepsanction/monitor/list HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/pepsanction/monitor/list")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/pepsanction/monitor/list"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/pepsanction/monitor/list")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/pepsanction/monitor/list")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/pepsanction/monitor/list');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/pepsanction/monitor/list',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/pepsanction/monitor/list';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/pepsanction/monitor/list',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/pepsanction/monitor/list")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/pepsanction/monitor/list',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/pepsanction/monitor/list',
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/pepsanction/monitor/list');

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/pepsanction/monitor/list',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/pepsanction/monitor/list';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/pepsanction/monitor/list"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/pepsanction/monitor/list" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/pepsanction/monitor/list",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/pepsanction/monitor/list', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/pepsanction/monitor/list');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/pepsanction/monitor/list');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/pepsanction/monitor/list' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/pepsanction/monitor/list' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/pepsanction/monitor/list", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/pepsanction/monitor/list"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/pepsanction/monitor/list"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/pepsanction/monitor/list")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/pepsanction/monitor/list') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/pepsanction/monitor/list";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/pepsanction/monitor/list \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/pepsanction/monitor/list \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/pepsanction/monitor/list

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/pepsanction/monitor/list")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns a json or pdf report

{{baseUrl}}/api/v1/pepsanction/retrieve/:id

HEADERS

user_key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/pepsanction/retrieve/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/pepsanction/retrieve/:id" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/pepsanction/retrieve/:id"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/pepsanction/retrieve/:id"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/pepsanction/retrieve/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/pepsanction/retrieve/:id"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/pepsanction/retrieve/:id HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/pepsanction/retrieve/:id")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/pepsanction/retrieve/:id"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/pepsanction/retrieve/:id")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/pepsanction/retrieve/:id")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/pepsanction/retrieve/:id');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/pepsanction/retrieve/:id',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/pepsanction/retrieve/:id';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/pepsanction/retrieve/:id',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/pepsanction/retrieve/:id")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/pepsanction/retrieve/:id',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/pepsanction/retrieve/:id',
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/pepsanction/retrieve/:id');

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/pepsanction/retrieve/:id',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/pepsanction/retrieve/:id';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/pepsanction/retrieve/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/pepsanction/retrieve/:id" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/pepsanction/retrieve/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/pepsanction/retrieve/:id', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/pepsanction/retrieve/:id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/pepsanction/retrieve/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/pepsanction/retrieve/:id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/pepsanction/retrieve/:id' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/pepsanction/retrieve/:id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/pepsanction/retrieve/:id"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/pepsanction/retrieve/:id"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/pepsanction/retrieve/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/pepsanction/retrieve/:id') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/pepsanction/retrieve/:id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/pepsanction/retrieve/:id \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/pepsanction/retrieve/:id \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/pepsanction/retrieve/:id

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/pepsanction/retrieve/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Update details of active Pep Sanction monitor

{{baseUrl}}/api/v1/pepsanction/monitor/update/:id

HEADERS

user_key

QUERY PARAMS

BODY formUrlEncoded

Webhook

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/pepsanction/monitor/update/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/pepsanction/monitor/update/:id" {:headers {:user_key "{{apiKey}}"
                                                                                            :content-type "application/x-www-form-urlencoded"}})

require "http/client"

url = "{{baseUrl}}/api/v1/pepsanction/monitor/update/:id"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/pepsanction/monitor/update/:id"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/pepsanction/monitor/update/:id");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/pepsanction/monitor/update/:id"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/pepsanction/monitor/update/:id HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/pepsanction/monitor/update/:id")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/pepsanction/monitor/update/:id"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/pepsanction/monitor/update/:id")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/pepsanction/monitor/update/:id")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/pepsanction/monitor/update/:id');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/pepsanction/monitor/update/:id',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/pepsanction/monitor/update/:id';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/pepsanction/monitor/update/:id',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/pepsanction/monitor/update/:id")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/pepsanction/monitor/update/:id',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/pepsanction/monitor/update/:id',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/pepsanction/monitor/update/:id');

req.headers({
  user_key: '{{apiKey}}',
  'content-type': 'application/x-www-form-urlencoded'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/pepsanction/monitor/update/:id',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/pepsanction/monitor/update/:id';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/pepsanction/monitor/update/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/pepsanction/monitor/update/:id" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/pepsanction/monitor/update/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/pepsanction/monitor/update/:id', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/pepsanction/monitor/update/:id');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/pepsanction/monitor/update/:id');
$request->setRequestMethod('POST');
$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/pepsanction/monitor/update/:id' -Method POST -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/pepsanction/monitor/update/:id' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

headers = {
    'user_key': "{{apiKey}}",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/api/v1/pepsanction/monitor/update/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/pepsanction/monitor/update/:id"

payload = ""
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/pepsanction/monitor/update/:id"

payload <- ""

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/pepsanction/monitor/update/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/api/v1/pepsanction/monitor/update/:id') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/pepsanction/monitor/update/:id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/pepsanction/monitor/update/:id \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}'

http POST {{baseUrl}}/api/v1/pepsanction/monitor/update/:id \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/api/v1/pepsanction/monitor/update/:id

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/pepsanction/monitor/update/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Creates a notifier for an order

{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri

HEADERS

user_key

QUERY PARAMS

orderId

type

uri

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/product/notifier/:orderId/:type/:uri HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri"))
    .header("user_key", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri';
const options = {method: 'POST', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/product/notifier/:orderId/:type/:uri',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri',
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri');

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri';
const options = {method: 'POST', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri');
$request->setRequestMethod('POST');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri' -Method POST -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("POST", "/baseUrl/api/v1/product/notifier/:orderId/:type/:uri", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri"

headers = {"user_key": "{{apiKey}}"}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri"

response <- VERB("POST", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/v1/product/notifier/:orderId/:type/:uri') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri \
  --header 'user_key: {{apiKey}}'

http POST {{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri \
  user_key:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/product/notifier/:orderId/:type/:uri")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Places a UBO order

{{baseUrl}}/api/v1/product/order/ubo

HEADERS

user_key

BODY formUrlEncoded

callbackUrl

credits

includeDocs

levels

strategy

subjectId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/product/order/ubo");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/product/order/ubo" {:headers {:user_key "{{apiKey}}"
                                                                               :content-type "application/x-www-form-urlencoded"}})

require "http/client"

url = "{{baseUrl}}/api/v1/product/order/ubo"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/product/order/ubo"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/product/order/ubo");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/product/order/ubo"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/product/order/ubo HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/product/order/ubo")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/product/order/ubo"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/product/order/ubo")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/product/order/ubo")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/product/order/ubo');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/order/ubo',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/product/order/ubo';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/product/order/ubo',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/product/order/ubo")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/product/order/ubo',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/order/ubo',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/product/order/ubo');

req.headers({
  user_key: '{{apiKey}}',
  'content-type': 'application/x-www-form-urlencoded'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/order/ubo',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/product/order/ubo';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/product/order/ubo"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/product/order/ubo" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/product/order/ubo",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/product/order/ubo', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/product/order/ubo');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/product/order/ubo');
$request->setRequestMethod('POST');
$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/product/order/ubo' -Method POST -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/product/order/ubo' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

headers = {
    'user_key': "{{apiKey}}",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/api/v1/product/order/ubo", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/product/order/ubo"

payload = ""
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/product/order/ubo"

payload <- ""

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/product/order/ubo")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/api/v1/product/order/ubo') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/product/order/ubo";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/product/order/ubo \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}'

http POST {{baseUrl}}/api/v1/product/order/ubo \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/api/v1/product/order/ubo

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/product/order/ubo")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Places a concierge order

{{baseUrl}}/api/v1/product/order/concierge

HEADERS

user_key

BODY formUrlEncoded

companyName

contactEmail

contactPhone

costConfirmation

country

financialData

historicInformation

informationRequirements

locationInvestigation

priority

registerData

registerNumber

subjectId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/product/order/concierge");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/product/order/concierge" {:headers {:user_key "{{apiKey}}"
                                                                                     :content-type "application/x-www-form-urlencoded"}})

require "http/client"

url = "{{baseUrl}}/api/v1/product/order/concierge"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/product/order/concierge"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/product/order/concierge");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/product/order/concierge"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/product/order/concierge HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/product/order/concierge")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/product/order/concierge"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/product/order/concierge")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/product/order/concierge")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/product/order/concierge');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/order/concierge',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/product/order/concierge';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/product/order/concierge',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/product/order/concierge")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/product/order/concierge',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/order/concierge',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/product/order/concierge');

req.headers({
  user_key: '{{apiKey}}',
  'content-type': 'application/x-www-form-urlencoded'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/order/concierge',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/product/order/concierge';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/product/order/concierge"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/product/order/concierge" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/product/order/concierge",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/product/order/concierge', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/product/order/concierge');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/product/order/concierge');
$request->setRequestMethod('POST');
$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/product/order/concierge' -Method POST -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/product/order/concierge' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

headers = {
    'user_key': "{{apiKey}}",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/api/v1/product/order/concierge", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/product/order/concierge"

payload = ""
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/product/order/concierge"

payload <- ""

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/product/order/concierge")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/api/v1/product/order/concierge') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/product/order/concierge";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/product/order/concierge \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}'

http POST {{baseUrl}}/api/v1/product/order/concierge \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/api/v1/product/order/concierge

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/product/order/concierge")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Places a product order (POST)

{{baseUrl}}/api/v1/product/order/:sku/:subjectId

HEADERS

user_key

QUERY PARAMS

sku

subjectId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/product/order/:sku/:subjectId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/product/order/:sku/:subjectId" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/product/order/:sku/:subjectId"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/product/order/:sku/:subjectId"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/product/order/:sku/:subjectId");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/product/order/:sku/:subjectId"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/product/order/:sku/:subjectId HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/product/order/:sku/:subjectId")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/product/order/:sku/:subjectId"))
    .header("user_key", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/product/order/:sku/:subjectId")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/product/order/:sku/:subjectId")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/product/order/:sku/:subjectId');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/order/:sku/:subjectId',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/product/order/:sku/:subjectId';
const options = {method: 'POST', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/product/order/:sku/:subjectId',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/product/order/:sku/:subjectId")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/product/order/:sku/:subjectId',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/order/:sku/:subjectId',
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/product/order/:sku/:subjectId');

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/order/:sku/:subjectId',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/product/order/:sku/:subjectId';
const options = {method: 'POST', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/product/order/:sku/:subjectId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/product/order/:sku/:subjectId" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/product/order/:sku/:subjectId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/product/order/:sku/:subjectId', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/product/order/:sku/:subjectId');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/product/order/:sku/:subjectId');
$request->setRequestMethod('POST');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/product/order/:sku/:subjectId' -Method POST -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/product/order/:sku/:subjectId' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("POST", "/baseUrl/api/v1/product/order/:sku/:subjectId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/product/order/:sku/:subjectId"

headers = {"user_key": "{{apiKey}}"}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/product/order/:sku/:subjectId"

response <- VERB("POST", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/product/order/:sku/:subjectId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/v1/product/order/:sku/:subjectId') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/product/order/:sku/:subjectId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/product/order/:sku/:subjectId \
  --header 'user_key: {{apiKey}}'

http POST {{baseUrl}}/api/v1/product/order/:sku/:subjectId \
  user_key:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/product/order/:sku/:subjectId

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/product/order/:sku/:subjectId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Places a product order

{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId

HEADERS

user_key

QUERY PARAMS

sku

option

subjectId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/product/order/:sku/:option/:subjectId HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId"))
    .header("user_key", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId';
const options = {method: 'POST', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/product/order/:sku/:option/:subjectId',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId',
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId');

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId';
const options = {method: 'POST', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId');
$request->setRequestMethod('POST');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId' -Method POST -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("POST", "/baseUrl/api/v1/product/order/:sku/:option/:subjectId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId"

headers = {"user_key": "{{apiKey}}"}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId"

response <- VERB("POST", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/v1/product/order/:sku/:option/:subjectId') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId \
  --header 'user_key: {{apiKey}}'

http POST {{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId \
  user_key:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/product/order/:sku/:option/:subjectId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Retrieves a document availability result

{{baseUrl}}/api/v1/product/availability/:sku/:subjectId

HEADERS

user_key

QUERY PARAMS

sku

subjectId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/product/availability/:sku/:subjectId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/product/availability/:sku/:subjectId" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/product/availability/:sku/:subjectId"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/product/availability/:sku/:subjectId"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/product/availability/:sku/:subjectId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/product/availability/:sku/:subjectId"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/product/availability/:sku/:subjectId HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/product/availability/:sku/:subjectId")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/product/availability/:sku/:subjectId"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/product/availability/:sku/:subjectId")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/product/availability/:sku/:subjectId")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/product/availability/:sku/:subjectId');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/availability/:sku/:subjectId',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/product/availability/:sku/:subjectId';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/product/availability/:sku/:subjectId',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/product/availability/:sku/:subjectId")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/product/availability/:sku/:subjectId',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/availability/:sku/:subjectId',
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/product/availability/:sku/:subjectId');

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/availability/:sku/:subjectId',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/product/availability/:sku/:subjectId';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/product/availability/:sku/:subjectId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/product/availability/:sku/:subjectId" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/product/availability/:sku/:subjectId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/product/availability/:sku/:subjectId', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/product/availability/:sku/:subjectId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/product/availability/:sku/:subjectId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/product/availability/:sku/:subjectId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/product/availability/:sku/:subjectId' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/product/availability/:sku/:subjectId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/product/availability/:sku/:subjectId"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/product/availability/:sku/:subjectId"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/product/availability/:sku/:subjectId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/product/availability/:sku/:subjectId') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/product/availability/:sku/:subjectId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/product/availability/:sku/:subjectId \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/product/availability/:sku/:subjectId \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/product/availability/:sku/:subjectId

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/product/availability/:sku/:subjectId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Retrieves the result of an order

{{baseUrl}}/api/v1/product/:orderId

HEADERS

user_key

QUERY PARAMS

orderId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/product/:orderId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/product/:orderId" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/product/:orderId"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/product/:orderId"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/product/:orderId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/product/:orderId"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/product/:orderId HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/product/:orderId")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/product/:orderId"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/product/:orderId")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/product/:orderId")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/product/:orderId');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/:orderId',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/product/:orderId';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/product/:orderId',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/product/:orderId")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/product/:orderId',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/:orderId',
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/product/:orderId');

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/:orderId',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/product/:orderId';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/product/:orderId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/product/:orderId" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/product/:orderId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/product/:orderId', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/product/:orderId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/product/:orderId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/product/:orderId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/product/:orderId' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/product/:orderId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/product/:orderId"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/product/:orderId"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/product/:orderId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/product/:orderId') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/product/:orderId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/product/:orderId \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/product/:orderId \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/product/:orderId

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/product/:orderId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns a catalog of products

{{baseUrl}}/api/v1/product/catalog/:country

HEADERS

user_key

QUERY PARAMS

country

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/product/catalog/:country");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/product/catalog/:country" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/product/catalog/:country"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/product/catalog/:country"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/product/catalog/:country");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/product/catalog/:country"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/product/catalog/:country HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/product/catalog/:country")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/product/catalog/:country"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/product/catalog/:country")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/product/catalog/:country")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/product/catalog/:country');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/catalog/:country',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/product/catalog/:country';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/product/catalog/:country',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/product/catalog/:country")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/product/catalog/:country',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/catalog/:country',
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/product/catalog/:country');

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/catalog/:country',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/product/catalog/:country';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/product/catalog/:country"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/product/catalog/:country" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/product/catalog/:country",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/product/catalog/:country', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/product/catalog/:country');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/product/catalog/:country');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/product/catalog/:country' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/product/catalog/:country' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/product/catalog/:country", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/product/catalog/:country"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/product/catalog/:country"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/product/catalog/:country")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/product/catalog/:country') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/product/catalog/:country";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/product/catalog/:country \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/product/catalog/:country \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/product/catalog/:country

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/product/catalog/:country")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns a list of products

{{baseUrl}}/api/v1/product/search/:subjectId

HEADERS

user_key

QUERY PARAMS

subjectId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/product/search/:subjectId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/product/search/:subjectId" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/product/search/:subjectId"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/product/search/:subjectId"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/product/search/:subjectId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/product/search/:subjectId"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/product/search/:subjectId HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/product/search/:subjectId")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/product/search/:subjectId"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/product/search/:subjectId")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/product/search/:subjectId")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/product/search/:subjectId');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/search/:subjectId',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/product/search/:subjectId';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/product/search/:subjectId',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/product/search/:subjectId")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/product/search/:subjectId',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/search/:subjectId',
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/product/search/:subjectId');

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/search/:subjectId',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/product/search/:subjectId';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/product/search/:subjectId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/product/search/:subjectId" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/product/search/:subjectId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/product/search/:subjectId', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/product/search/:subjectId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/product/search/:subjectId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/product/search/:subjectId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/product/search/:subjectId' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/product/search/:subjectId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/product/search/:subjectId"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/product/search/:subjectId"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/product/search/:subjectId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/product/search/:subjectId') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/product/search/:subjectId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/product/search/:subjectId \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/product/search/:subjectId \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/product/search/:subjectId

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/product/search/:subjectId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns metadata for a notifier

{{baseUrl}}/api/v1/product/notifier/:notifierId

HEADERS

user_key

QUERY PARAMS

notifierId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/product/notifier/:notifierId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/product/notifier/:notifierId" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/product/notifier/:notifierId"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/product/notifier/:notifierId"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/product/notifier/:notifierId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/product/notifier/:notifierId"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/product/notifier/:notifierId HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/product/notifier/:notifierId")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/product/notifier/:notifierId"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/product/notifier/:notifierId")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/product/notifier/:notifierId")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/product/notifier/:notifierId');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/notifier/:notifierId',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/product/notifier/:notifierId';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/product/notifier/:notifierId',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/product/notifier/:notifierId")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/product/notifier/:notifierId',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/notifier/:notifierId',
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/product/notifier/:notifierId');

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/notifier/:notifierId',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/product/notifier/:notifierId';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/product/notifier/:notifierId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/product/notifier/:notifierId" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/product/notifier/:notifierId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/product/notifier/:notifierId', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/product/notifier/:notifierId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/product/notifier/:notifierId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/product/notifier/:notifierId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/product/notifier/:notifierId' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/product/notifier/:notifierId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/product/notifier/:notifierId"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/product/notifier/:notifierId"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/product/notifier/:notifierId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/product/notifier/:notifierId') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/product/notifier/:notifierId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/product/notifier/:notifierId \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/product/notifier/:notifierId \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/product/notifier/:notifierId

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/product/notifier/:notifierId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns metadata for a order

{{baseUrl}}/api/v1/product/status/:orderId

HEADERS

user_key

QUERY PARAMS

orderId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/product/status/:orderId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/product/status/:orderId" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/product/status/:orderId"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/product/status/:orderId"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/product/status/:orderId");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/product/status/:orderId"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/product/status/:orderId HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/product/status/:orderId")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/product/status/:orderId"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/product/status/:orderId")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/product/status/:orderId")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/product/status/:orderId');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/status/:orderId',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/product/status/:orderId';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/product/status/:orderId',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/product/status/:orderId")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/product/status/:orderId',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/status/:orderId',
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/product/status/:orderId');

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/product/status/:orderId',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/product/status/:orderId';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/product/status/:orderId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/product/status/:orderId" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/product/status/:orderId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/product/status/:orderId', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/product/status/:orderId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/product/status/:orderId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/product/status/:orderId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/product/status/:orderId' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/product/status/:orderId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/product/status/:orderId"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/product/status/:orderId"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/product/status/:orderId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/product/status/:orderId') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/product/status/:orderId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/product/status/:orderId \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/product/status/:orderId \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/product/status/:orderId

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/product/status/:orderId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Updates metadata of an order

{{baseUrl}}/api/v1/product/update/:action/:orderId

HEADERS

user_key

QUERY PARAMS

action

orderId

BODY formUrlEncoded

credits

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/product/update/:action/:orderId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/product/update/:action/:orderId" {:headers {:user_key "{{apiKey}}"
                                                                                             :content-type "application/x-www-form-urlencoded"}})

require "http/client"

url = "{{baseUrl}}/api/v1/product/update/:action/:orderId"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/product/update/:action/:orderId"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/product/update/:action/:orderId");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/product/update/:action/:orderId"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/product/update/:action/:orderId HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/product/update/:action/:orderId")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/product/update/:action/:orderId"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/product/update/:action/:orderId")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/product/update/:action/:orderId")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/product/update/:action/:orderId');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/update/:action/:orderId',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/product/update/:action/:orderId';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/product/update/:action/:orderId',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/product/update/:action/:orderId")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/product/update/:action/:orderId',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/update/:action/:orderId',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/product/update/:action/:orderId');

req.headers({
  user_key: '{{apiKey}}',
  'content-type': 'application/x-www-form-urlencoded'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/product/update/:action/:orderId',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/product/update/:action/:orderId';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/product/update/:action/:orderId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/product/update/:action/:orderId" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/product/update/:action/:orderId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/product/update/:action/:orderId', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/product/update/:action/:orderId');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/product/update/:action/:orderId');
$request->setRequestMethod('POST');
$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/product/update/:action/:orderId' -Method POST -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/product/update/:action/:orderId' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

headers = {
    'user_key': "{{apiKey}}",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/api/v1/product/update/:action/:orderId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/product/update/:action/:orderId"

payload = ""
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/product/update/:action/:orderId"

payload <- ""

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/product/update/:action/:orderId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/api/v1/product/update/:action/:orderId') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/product/update/:action/:orderId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/product/update/:action/:orderId \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}'

http POST {{baseUrl}}/api/v1/product/update/:action/:orderId \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/api/v1/product/update/:action/:orderId

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/product/update/:action/:orderId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns a list of countries

{{baseUrl}}/api/v1/system/countries

HEADERS

user_key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/system/countries");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/system/countries" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/system/countries"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/system/countries"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/system/countries");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/system/countries"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/system/countries HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/system/countries")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/system/countries"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/system/countries")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/system/countries")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/system/countries');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/system/countries',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/system/countries';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/system/countries',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/system/countries")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/system/countries',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/system/countries',
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/system/countries');

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/system/countries',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/system/countries';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/system/countries"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/system/countries" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/system/countries",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/system/countries', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/system/countries');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/system/countries');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/system/countries' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/system/countries' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/system/countries", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/system/countries"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/system/countries"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/system/countries")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/system/countries') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/system/countries";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/system/countries \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/system/countries \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/system/countries

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/system/countries")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns a list of products with prices

{{baseUrl}}/api/v1/system/pricelist

HEADERS

user_key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/system/pricelist");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/system/pricelist" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/system/pricelist"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/system/pricelist"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/system/pricelist");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/system/pricelist"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/system/pricelist HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/system/pricelist")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/system/pricelist"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/system/pricelist")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/system/pricelist")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/system/pricelist');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/system/pricelist',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/system/pricelist';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/system/pricelist',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/system/pricelist")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/system/pricelist',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/system/pricelist',
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/system/pricelist');

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/system/pricelist',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/system/pricelist';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/system/pricelist"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/system/pricelist" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/system/pricelist",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/system/pricelist', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/system/pricelist');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/system/pricelist');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/system/pricelist' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/system/pricelist' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/system/pricelist", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/system/pricelist"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/system/pricelist"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/system/pricelist")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/system/pricelist') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/system/pricelist";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/system/pricelist \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/system/pricelist \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/system/pricelist

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/system/pricelist")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns the health information for the official business registers based on usage.

{{baseUrl}}/api/v1/system/health

HEADERS

user_key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/system/health");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/system/health" {:headers {:user_key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/v1/system/health"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/system/health"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/system/health");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/system/health"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/system/health HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/system/health")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/system/health"))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/system/health")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/system/health")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/system/health');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/system/health',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/system/health';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/system/health',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/system/health")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/system/health',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/system/health',
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/system/health');

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/system/health',
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/system/health';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/system/health"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/system/health" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/system/health",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/system/health', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/system/health');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/system/health');
$request->setRequestMethod('GET');
$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/system/health' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/system/health' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/system/health", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/system/health"

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/system/health"

response <- VERB("GET", url, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/system/health")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/system/health') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/system/health";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/v1/system/health \
  --header 'user_key: {{apiKey}}'

http GET {{baseUrl}}/api/v1/system/health \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/system/health

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/system/health")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET EIN Name Lookup with TIN number and retrieves company data

{{baseUrl}}/api/v1/tin-verification/comprehensive-check

HEADERS

user_key

QUERY PARAMS

tin

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/tin-verification/comprehensive-check" {:headers {:user_key "{{apiKey}}"}
                                                                                       :query-params {:tin ""
                                                                                                      :name ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name="
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name="),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/tin-verification/comprehensive-check?tin=&name= HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name="))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/tin-verification/comprehensive-check',
  params: {tin: '', name: ''},
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/tin-verification/comprehensive-check?tin=&name=',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/tin-verification/comprehensive-check',
  qs: {tin: '', name: ''},
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/tin-verification/comprehensive-check');

req.query({
  tin: '',
  name: ''
});

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/tin-verification/comprehensive-check',
  params: {tin: '', name: ''},
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/tin-verification/comprehensive-check');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'tin' => '',
  'name' => ''
]);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/tin-verification/comprehensive-check');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'tin' => '',
  'name' => ''
]));

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/tin-verification/comprehensive-check?tin=&name=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/tin-verification/comprehensive-check"

querystring = {"tin":"","name":""}

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/tin-verification/comprehensive-check"

queryString <- list(
  tin = "",
  name = ""
)

response <- VERB("GET", url, query = queryString, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/tin-verification/comprehensive-check') do |req|
  req.headers['user_key'] = '{{apiKey}}'
  req.params['tin'] = ''
  req.params['name'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/tin-verification/comprehensive-check";

    let querystring = [
        ("tin", ""),
        ("name", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=' \
  --header 'user_key: {{apiKey}}'

http GET '{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=' \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name='

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/tin-verification/comprehensive-check?tin=&name=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET EIN Name Lookup with TIN number

{{baseUrl}}/api/v1/tin-verification/name-lookup

HEADERS

user_key

QUERY PARAMS

tin

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/tin-verification/name-lookup" {:headers {:user_key "{{apiKey}}"}
                                                                               :query-params {:tin ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/tin-verification/name-lookup?tin="
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/tin-verification/name-lookup?tin="),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/tin-verification/name-lookup?tin="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/tin-verification/name-lookup?tin= HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/tin-verification/name-lookup?tin="))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/tin-verification/name-lookup',
  params: {tin: ''},
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/tin-verification/name-lookup?tin=',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/tin-verification/name-lookup',
  qs: {tin: ''},
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/tin-verification/name-lookup');

req.query({
  tin: ''
});

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/tin-verification/name-lookup',
  params: {tin: ''},
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/tin-verification/name-lookup?tin="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/tin-verification/name-lookup');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'tin' => ''
]);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/tin-verification/name-lookup');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'tin' => ''
]));

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/tin-verification/name-lookup?tin=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/tin-verification/name-lookup"

querystring = {"tin":""}

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/tin-verification/name-lookup"

queryString <- list(tin = "")

response <- VERB("GET", url, query = queryString, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/tin-verification/name-lookup') do |req|
  req.headers['user_key'] = '{{apiKey}}'
  req.params['tin'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/tin-verification/name-lookup";

    let querystring = [
        ("tin", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=' \
  --header 'user_key: {{apiKey}}'

http GET '{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=' \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/api/v1/tin-verification/name-lookup?tin='

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/tin-verification/name-lookup?tin=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Verifies a TIN number

{{baseUrl}}/api/v1/tin-verification/basic-check

HEADERS

user_key

QUERY PARAMS

tin

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/tin-verification/basic-check" {:headers {:user_key "{{apiKey}}"}
                                                                               :query-params {:tin ""
                                                                                              :name ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name="
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name="),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=");
var request = new RestRequest("", Method.Get);
request.AddHeader("user_key", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/tin-verification/basic-check?tin=&name= HTTP/1.1
User_key: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=")
  .setHeader("user_key", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name="))
    .header("user_key", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=")
  .header("user_key", "{{apiKey}}")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=');
xhr.setRequestHeader('user_key', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/tin-verification/basic-check',
  params: {tin: '', name: ''},
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=',
  method: 'GET',
  headers: {
    user_key: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=")
  .get()
  .addHeader("user_key", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/tin-verification/basic-check?tin=&name=',
  headers: {
    user_key: '{{apiKey}}'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/tin-verification/basic-check',
  qs: {tin: '', name: ''},
  headers: {user_key: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/tin-verification/basic-check');

req.query({
  tin: '',
  name: ''
});

req.headers({
  user_key: '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/tin-verification/basic-check',
  params: {tin: '', name: ''},
  headers: {user_key: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=';
const options = {method: 'GET', headers: {user_key: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=" in
let headers = Header.add (Header.init ()) "user_key" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=', [
  'headers' => [
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/tin-verification/basic-check');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'tin' => '',
  'name' => ''
]);

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/tin-verification/basic-check');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'tin' => '',
  'name' => ''
]));

$request->setHeaders([
  'user_key' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'user_key': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/tin-verification/basic-check?tin=&name=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/tin-verification/basic-check"

querystring = {"tin":"","name":""}

headers = {"user_key": "{{apiKey}}"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/tin-verification/basic-check"

queryString <- list(
  tin = "",
  name = ""
)

response <- VERB("GET", url, query = queryString, add_headers('user_key' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["user_key"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/tin-verification/basic-check') do |req|
  req.headers['user_key'] = '{{apiKey}}'
  req.params['tin'] = ''
  req.params['name'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/tin-verification/basic-check";

    let querystring = [
        ("tin", ""),
        ("name", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=' \
  --header 'user_key: {{apiKey}}'

http GET '{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=' \
  user_key:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'user_key: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name='

import Foundation

let headers = ["user_key": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/tin-verification/basic-check?tin=&name=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Returns a level two verification result

{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country

HEADERS

user_key

QUERY PARAMS

country

BODY formUrlEncoded

confirmation

vatNumber

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "confirmation=&vatNumber=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country" {:headers {:user_key "{{apiKey}}"}
                                                                                            :form-params {:confirmation ""
                                                                                                          :vatNumber ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "confirmation=&vatNumber="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "confirmation", "" },
        { "vatNumber", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "confirmation=&vatNumber=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country"

	payload := strings.NewReader("confirmation=&vatNumber=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("user_key", "{{apiKey}}")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/vat-verification/leveltwo-check/:country HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 24

confirmation=&vatNumber=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("confirmation=&vatNumber=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("confirmation=&vatNumber="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "confirmation=&vatNumber=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("confirmation=&vatNumber=")
  .asString();

const data = 'confirmation=&vatNumber=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('confirmation', '');
encodedParams.set('vatNumber', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({confirmation: '', vatNumber: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    confirmation: '',
    vatNumber: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "confirmation=&vatNumber=")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/vat-verification/leveltwo-check/:country',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({confirmation: '', vatNumber: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  form: {confirmation: '', vatNumber: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country');

req.headers({
  user_key: '{{apiKey}}',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  confirmation: '',
  vatNumber: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('confirmation', '');
encodedParams.set('vatNumber', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('confirmation', '');
encodedParams.set('vatNumber', '');

const url = '{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"confirmation=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&vatNumber=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "confirmation=&vatNumber=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "confirmation=&vatNumber=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country', [
  'form_params' => [
    'confirmation' => '',
    'vatNumber' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'confirmation' => '',
  'vatNumber' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'confirmation' => '',
  'vatNumber' => ''
]));

$request->setRequestUrl('{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'confirmation=&vatNumber='

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'confirmation=&vatNumber='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "confirmation=&vatNumber="

headers = {
    'user_key': "{{apiKey}}",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/api/v1/vat-verification/leveltwo-check/:country", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country"

payload = {
    "confirmation": "",
    "vatNumber": ""
}
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country"

payload <- "confirmation=&vatNumber="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "confirmation=&vatNumber="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :confirmation => "",
  :vatNumber => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/api/v1/vat-verification/leveltwo-check/:country') do |req|
  req.headers['user_key'] = '{{apiKey}}'
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country";

    let payload = json!({
        "confirmation": "",
        "vatNumber": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}' \
  --data confirmation= \
  --data vatNumber=

http --form POST {{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}' \
  confirmation='' \
  vatNumber=''

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'confirmation=&vatNumber=' \
  --output-document \
  - {{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "confirmation=".data(using: String.Encoding.utf8)!)
postData.append("&vatNumber=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/vat-verification/leveltwo-check/:country")! 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 Returns a list of vat numbers with additional data

{{baseUrl}}/api/v1/vat-verification/lookup/:country

HEADERS

user_key

QUERY PARAMS

country

BODY formUrlEncoded

address

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/vat-verification/lookup/:country");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/vat-verification/lookup/:country" {:headers {:user_key "{{apiKey}}"
                                                                                              :content-type "application/x-www-form-urlencoded"}})

require "http/client"

url = "{{baseUrl}}/api/v1/vat-verification/lookup/:country"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/vat-verification/lookup/:country"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/vat-verification/lookup/:country");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/vat-verification/lookup/:country"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("user_key", "{{apiKey}}")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/vat-verification/lookup/:country HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/vat-verification/lookup/:country")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/vat-verification/lookup/:country"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/vat-verification/lookup/:country")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/vat-verification/lookup/:country")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/vat-verification/lookup/:country');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/vat-verification/lookup/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/vat-verification/lookup/:country';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/vat-verification/lookup/:country',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/vat-verification/lookup/:country")
  .post(null)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/vat-verification/lookup/:country',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/vat-verification/lookup/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/vat-verification/lookup/:country');

req.headers({
  user_key: '{{apiKey}}',
  'content-type': 'application/x-www-form-urlencoded'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/vat-verification/lookup/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/vat-verification/lookup/:country';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/vat-verification/lookup/:country"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/vat-verification/lookup/:country" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/vat-verification/lookup/:country",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/vat-verification/lookup/:country', [
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/vat-verification/lookup/:country');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/vat-verification/lookup/:country');
$request->setRequestMethod('POST');
$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/vat-verification/lookup/:country' -Method POST -Headers $headers

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/vat-verification/lookup/:country' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

headers = {
    'user_key': "{{apiKey}}",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/api/v1/vat-verification/lookup/:country", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/vat-verification/lookup/:country"

payload = ""
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/vat-verification/lookup/:country"

payload <- ""

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/vat-verification/lookup/:country")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/api/v1/vat-verification/lookup/:country') do |req|
  req.headers['user_key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/vat-verification/lookup/:country";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/vat-verification/lookup/:country \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}'

http POST {{baseUrl}}/api/v1/vat-verification/lookup/:country \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --output-document \
  - {{baseUrl}}/api/v1/vat-verification/lookup/:country

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/vat-verification/lookup/:country")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Returns a verification result and company data

{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country

HEADERS

user_key

QUERY PARAMS

country

BODY formUrlEncoded

companyAddress

companyName

companyNumber

vatNumber

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "companyAddress=&companyName=&companyNumber=&vatNumber=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country" {:headers {:user_key "{{apiKey}}"}
                                                                                                 :form-params {:companyAddress ""
                                                                                                               :companyName ""
                                                                                                               :companyNumber ""
                                                                                                               :vatNumber ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "companyAddress=&companyName=&companyNumber=&vatNumber="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "companyAddress", "" },
        { "companyName", "" },
        { "companyNumber", "" },
        { "vatNumber", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "companyAddress=&companyName=&companyNumber=&vatNumber=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country"

	payload := strings.NewReader("companyAddress=&companyName=&companyNumber=&vatNumber=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("user_key", "{{apiKey}}")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/vat-verification/comprehensive-check/:country HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 54

companyAddress=&companyName=&companyNumber=&vatNumber=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("companyAddress=&companyName=&companyNumber=&vatNumber=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("companyAddress=&companyName=&companyNumber=&vatNumber="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "companyAddress=&companyName=&companyNumber=&vatNumber=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("companyAddress=&companyName=&companyNumber=&vatNumber=")
  .asString();

const data = 'companyAddress=&companyName=&companyNumber=&vatNumber=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('companyAddress', '');
encodedParams.set('companyName', '');
encodedParams.set('companyNumber', '');
encodedParams.set('vatNumber', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({companyAddress: '', companyName: '', companyNumber: '', vatNumber: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    companyAddress: '',
    companyName: '',
    companyNumber: '',
    vatNumber: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "companyAddress=&companyName=&companyNumber=&vatNumber=")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/vat-verification/comprehensive-check/:country',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({companyAddress: '', companyName: '', companyNumber: '', vatNumber: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  form: {companyAddress: '', companyName: '', companyNumber: '', vatNumber: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country');

req.headers({
  user_key: '{{apiKey}}',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  companyAddress: '',
  companyName: '',
  companyNumber: '',
  vatNumber: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('companyAddress', '');
encodedParams.set('companyName', '');
encodedParams.set('companyNumber', '');
encodedParams.set('vatNumber', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('companyAddress', '');
encodedParams.set('companyName', '');
encodedParams.set('companyNumber', '');
encodedParams.set('vatNumber', '');

const url = '{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"companyAddress=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&companyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&companyNumber=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&vatNumber=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "companyAddress=&companyName=&companyNumber=&vatNumber=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "companyAddress=&companyName=&companyNumber=&vatNumber=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country', [
  'form_params' => [
    'companyAddress' => '',
    'companyName' => '',
    'companyNumber' => '',
    'vatNumber' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'companyAddress' => '',
  'companyName' => '',
  'companyNumber' => '',
  'vatNumber' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'companyAddress' => '',
  'companyName' => '',
  'companyNumber' => '',
  'vatNumber' => ''
]));

$request->setRequestUrl('{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'companyAddress=&companyName=&companyNumber=&vatNumber='

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'companyAddress=&companyName=&companyNumber=&vatNumber='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "companyAddress=&companyName=&companyNumber=&vatNumber="

headers = {
    'user_key': "{{apiKey}}",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/api/v1/vat-verification/comprehensive-check/:country", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country"

payload = {
    "companyAddress": "",
    "companyName": "",
    "companyNumber": "",
    "vatNumber": ""
}
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country"

payload <- "companyAddress=&companyName=&companyNumber=&vatNumber="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "companyAddress=&companyName=&companyNumber=&vatNumber="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :companyAddress => "",
  :companyName => "",
  :companyNumber => "",
  :vatNumber => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/api/v1/vat-verification/comprehensive-check/:country') do |req|
  req.headers['user_key'] = '{{apiKey}}'
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country";

    let payload = json!({
        "companyAddress": "",
        "companyName": "",
        "companyNumber": "",
        "vatNumber": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}' \
  --data companyAddress= \
  --data companyName= \
  --data companyNumber= \
  --data vatNumber=

http --form POST {{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}' \
  companyAddress='' \
  companyName='' \
  companyNumber='' \
  vatNumber=''

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'companyAddress=&companyName=&companyNumber=&vatNumber=' \
  --output-document \
  - {{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "companyAddress=".data(using: String.Encoding.utf8)!)
postData.append("&companyName=".data(using: String.Encoding.utf8)!)
postData.append("&companyNumber=".data(using: String.Encoding.utf8)!)
postData.append("&vatNumber=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/vat-verification/comprehensive-check/:country")! 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 Returns a verification result

{{baseUrl}}/api/v1/vat-verification/basic-check/:country

HEADERS

user_key

QUERY PARAMS

country

BODY formUrlEncoded

companyAddress

companyName

companyNumber

vatNumber

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/vat-verification/basic-check/:country");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "user_key: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "companyAddress=&companyName=&companyNumber=&vatNumber=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/vat-verification/basic-check/:country" {:headers {:user_key "{{apiKey}}"}
                                                                                         :form-params {:companyAddress ""
                                                                                                       :companyName ""
                                                                                                       :companyNumber ""
                                                                                                       :vatNumber ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/vat-verification/basic-check/:country"
headers = HTTP::Headers{
  "user_key" => "{{apiKey}}"
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "companyAddress=&companyName=&companyNumber=&vatNumber="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/vat-verification/basic-check/:country"),
    Headers =
    {
        { "user_key", "{{apiKey}}" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "companyAddress", "" },
        { "companyName", "" },
        { "companyNumber", "" },
        { "vatNumber", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/vat-verification/basic-check/:country");
var request = new RestRequest("", Method.Post);
request.AddHeader("user_key", "{{apiKey}}");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "companyAddress=&companyName=&companyNumber=&vatNumber=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/vat-verification/basic-check/:country"

	payload := strings.NewReader("companyAddress=&companyName=&companyNumber=&vatNumber=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("user_key", "{{apiKey}}")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/vat-verification/basic-check/:country HTTP/1.1
User_key: {{apiKey}}
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 54

companyAddress=&companyName=&companyNumber=&vatNumber=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/vat-verification/basic-check/:country")
  .setHeader("user_key", "{{apiKey}}")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("companyAddress=&companyName=&companyNumber=&vatNumber=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/vat-verification/basic-check/:country"))
    .header("user_key", "{{apiKey}}")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("companyAddress=&companyName=&companyNumber=&vatNumber="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "companyAddress=&companyName=&companyNumber=&vatNumber=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/vat-verification/basic-check/:country")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/vat-verification/basic-check/:country")
  .header("user_key", "{{apiKey}}")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("companyAddress=&companyName=&companyNumber=&vatNumber=")
  .asString();

const data = 'companyAddress=&companyName=&companyNumber=&vatNumber=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/vat-verification/basic-check/:country');
xhr.setRequestHeader('user_key', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('companyAddress', '');
encodedParams.set('companyName', '');
encodedParams.set('companyNumber', '');
encodedParams.set('vatNumber', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/vat-verification/basic-check/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/vat-verification/basic-check/:country';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({companyAddress: '', companyName: '', companyNumber: '', vatNumber: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/vat-verification/basic-check/:country',
  method: 'POST',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    companyAddress: '',
    companyName: '',
    companyNumber: '',
    vatNumber: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "companyAddress=&companyName=&companyNumber=&vatNumber=")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/vat-verification/basic-check/:country")
  .post(body)
  .addHeader("user_key", "{{apiKey}}")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/vat-verification/basic-check/:country',
  headers: {
    user_key: '{{apiKey}}',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({companyAddress: '', companyName: '', companyNumber: '', vatNumber: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/vat-verification/basic-check/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  form: {companyAddress: '', companyName: '', companyNumber: '', vatNumber: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/vat-verification/basic-check/:country');

req.headers({
  user_key: '{{apiKey}}',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  companyAddress: '',
  companyName: '',
  companyNumber: '',
  vatNumber: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('companyAddress', '');
encodedParams.set('companyName', '');
encodedParams.set('companyNumber', '');
encodedParams.set('vatNumber', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/vat-verification/basic-check/:country',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('companyAddress', '');
encodedParams.set('companyName', '');
encodedParams.set('companyNumber', '');
encodedParams.set('vatNumber', '');

const url = '{{baseUrl}}/api/v1/vat-verification/basic-check/:country';
const options = {
  method: 'POST',
  headers: {user_key: '{{apiKey}}', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"user_key": @"{{apiKey}}",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"companyAddress=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&companyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&companyNumber=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&vatNumber=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/vat-verification/basic-check/:country"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/vat-verification/basic-check/:country" in
let headers = Header.add_list (Header.init ()) [
  ("user_key", "{{apiKey}}");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "companyAddress=&companyName=&companyNumber=&vatNumber=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/vat-verification/basic-check/:country",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "companyAddress=&companyName=&companyNumber=&vatNumber=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "user_key: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/vat-verification/basic-check/:country', [
  'form_params' => [
    'companyAddress' => '',
    'companyName' => '',
    'companyNumber' => '',
    'vatNumber' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'user_key' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/vat-verification/basic-check/:country');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'companyAddress' => '',
  'companyName' => '',
  'companyNumber' => '',
  'vatNumber' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'companyAddress' => '',
  'companyName' => '',
  'companyNumber' => '',
  'vatNumber' => ''
]));

$request->setRequestUrl('{{baseUrl}}/api/v1/vat-verification/basic-check/:country');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'user_key' => '{{apiKey}}',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/vat-verification/basic-check/:country' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'companyAddress=&companyName=&companyNumber=&vatNumber='

$headers=@{}
$headers.Add("user_key", "{{apiKey}}")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/vat-verification/basic-check/:country' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'companyAddress=&companyName=&companyNumber=&vatNumber='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "companyAddress=&companyName=&companyNumber=&vatNumber="

headers = {
    'user_key': "{{apiKey}}",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/api/v1/vat-verification/basic-check/:country", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/vat-verification/basic-check/:country"

payload = {
    "companyAddress": "",
    "companyName": "",
    "companyNumber": "",
    "vatNumber": ""
}
headers = {
    "user_key": "{{apiKey}}",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/vat-verification/basic-check/:country"

payload <- "companyAddress=&companyName=&companyNumber=&vatNumber="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('user_key' = '{{apiKey}}'), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/vat-verification/basic-check/:country")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["user_key"] = '{{apiKey}}'
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "companyAddress=&companyName=&companyNumber=&vatNumber="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :companyAddress => "",
  :companyName => "",
  :companyNumber => "",
  :vatNumber => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/api/v1/vat-verification/basic-check/:country') do |req|
  req.headers['user_key'] = '{{apiKey}}'
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/vat-verification/basic-check/:country";

    let payload = json!({
        "companyAddress": "",
        "companyName": "",
        "companyNumber": "",
        "vatNumber": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("user_key", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/vat-verification/basic-check/:country \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'user_key: {{apiKey}}' \
  --data companyAddress= \
  --data companyName= \
  --data companyNumber= \
  --data vatNumber=

http --form POST {{baseUrl}}/api/v1/vat-verification/basic-check/:country \
  content-type:application/x-www-form-urlencoded \
  user_key:'{{apiKey}}' \
  companyAddress='' \
  companyName='' \
  companyNumber='' \
  vatNumber=''

wget --quiet \
  --method POST \
  --header 'user_key: {{apiKey}}' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'companyAddress=&companyName=&companyNumber=&vatNumber=' \
  --output-document \
  - {{baseUrl}}/api/v1/vat-verification/basic-check/:country

import Foundation

let headers = [
  "user_key": "{{apiKey}}",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "companyAddress=".data(using: String.Encoding.utf8)!)
postData.append("&companyName=".data(using: String.Encoding.utf8)!)
postData.append("&companyNumber=".data(using: String.Encoding.utf8)!)
postData.append("&vatNumber=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/vat-verification/basic-check/:country")! 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()