Credas API

POST Verifies bank account details.

{{baseUrl}}/api/bank-accounts/verify

HEADERS

apikey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/bank-accounts/verify");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/bank-accounts/verify" {:headers {:apikey ""}})

require "http/client"

url = "{{baseUrl}}/api/bank-accounts/verify"
headers = HTTP::Headers{
  "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/bank-accounts/verify"),
    Headers =
    {
        { "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/bank-accounts/verify");
var request = new RestRequest("", Method.Post);
request.AddHeader("apikey", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/bank-accounts/verify"

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

	req.Header.Add("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/bank-accounts/verify HTTP/1.1
Apikey: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/bank-accounts/verify")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/bank-accounts/verify"))
    .header("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/bank-accounts/verify")
  .post(null)
  .addHeader("apikey", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/bank-accounts/verify")
  .header("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/bank-accounts/verify');
xhr.setRequestHeader('apikey', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/bank-accounts/verify',
  headers: {apikey: ''}
};

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

const url = '{{baseUrl}}/api/bank-accounts/verify';
const options = {method: 'POST', headers: {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/bank-accounts/verify',
  method: 'POST',
  headers: {
    apikey: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/bank-accounts/verify")
  .post(null)
  .addHeader("apikey", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/bank-accounts/verify',
  headers: {
    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/bank-accounts/verify',
  headers: {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/bank-accounts/verify');

req.headers({
  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/bank-accounts/verify',
  headers: {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/bank-accounts/verify';
const options = {method: 'POST', headers: {apikey: ''}};

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

#import 

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/bank-accounts/verify"]
                                                       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/bank-accounts/verify" in
let headers = Header.add (Header.init ()) "apikey" "" in

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

 "{{baseUrl}}/api/bank-accounts/verify",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "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/bank-accounts/verify', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/bank-accounts/verify');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'apikey' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/bank-accounts/verify');
$request->setRequestMethod('POST');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/bank-accounts/verify' -Method POST -Headers $headers

$headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/bank-accounts/verify' -Method POST -Headers $headers

import http.client

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

headers = { 'apikey': "" }

conn.request("POST", "/baseUrl/api/bank-accounts/verify", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/bank-accounts/verify"

headers = {"apikey": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/bank-accounts/verify"

response <- VERB("POST", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/bank-accounts/verify")

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

request = Net::HTTP::Post.new(url)
request["apikey"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/api/bank-accounts/verify') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/bank-accounts/verify";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/bank-accounts/verify \
  --header 'apikey: '

http POST {{baseUrl}}/api/bank-accounts/verify \
  apikey:''

wget --quiet \
  --method POST \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/bank-accounts/verify

import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/bank-accounts/verify")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "Address1": null,
  "City": null,
  "Forename": null,
  "MiddleName": null,
  "PostCode": null,
  "Surname": null,
  "accountNumber": "12345678",
  "accountNumberValidation": 2,
  "accountNumberValidationText": "Valid",
  "accountStatus": 2,
  "accountStatusText": "Live",
  "accountValid": true,
  "addressValidation": 2,
  "addressValidationText": "Current address",
  "checkDate": "2019-08-01T12:15:22",
  "checkId": "12345678-1234-5678-abcd-1234567890ab",
  "checkStatus": 1,
  "error": false,
  "hasBeenOverridden": false,
  "nameValidation": 2,
  "nameValidationText": "Valid",
  "referenceId": "RF1234",
  "sortcode": "123456",
  "sortcodeValidation": 2,
  "sortcodeValidationText": "Valid"
}

GET GetCompany

{{baseUrl}}/api/companies/:companyId

HEADERS

apikey

QUERY PARAMS

companyId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/companies/:companyId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/companies/:companyId" {:headers {:apikey ""}})

require "http/client"

url = "{{baseUrl}}/api/companies/:companyId"
headers = HTTP::Headers{
  "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/companies/:companyId"),
    Headers =
    {
        { "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/companies/:companyId");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/companies/:companyId"

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

	req.Header.Add("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/companies/:companyId HTTP/1.1
Apikey: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/companies/:companyId")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/companies/:companyId"))
    .header("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/companies/:companyId")
  .get()
  .addHeader("apikey", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/companies/:companyId")
  .header("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/companies/:companyId');
xhr.setRequestHeader('apikey', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/companies/:companyId',
  headers: {apikey: ''}
};

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

const url = '{{baseUrl}}/api/companies/:companyId';
const options = {method: 'GET', headers: {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/companies/:companyId',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/companies/:companyId")
  .get()
  .addHeader("apikey", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/companies/:companyId',
  headers: {
    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/companies/:companyId',
  headers: {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/companies/:companyId');

req.headers({
  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/companies/:companyId',
  headers: {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/companies/:companyId';
const options = {method: 'GET', headers: {apikey: ''}};

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

#import 

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/companies/:companyId"]
                                                       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/companies/:companyId" in
let headers = Header.add (Header.init ()) "apikey" "" in

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

 "{{baseUrl}}/api/companies/:companyId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/companies/:companyId', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/companies/:companyId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/companies/:companyId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/companies/:companyId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/companies/:companyId' -Method GET -Headers $headers

import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/companies/:companyId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/companies/:companyId"

headers = {"apikey": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/companies/:companyId"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/companies/:companyId")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/api/companies/:companyId') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/companies/:companyId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/companies/:companyId \
  --header 'apikey: '

http GET {{baseUrl}}/api/companies/:companyId \
  apikey:''

wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/companies/:companyId

import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/companies/:companyId")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "addressLine1": "25 Westgate Street",
  "companyName": "Widget Production Limited",
  "companyNumber": "12345678",
  "dateOfRegistration": "1973-07-17T00:00:00",
  "duplicate": false,
  "id": "38eba446-0ff9-4602-9694-ee7f786ef9b1",
  "locality": "",
  "postCode": "CF101NS",
  "region": "Cardiff",
  "significantParentCompanies": [
    {
      "addressLine1": null,
      "companyName": "Widgets International Limited",
      "companyNumber": "54345678",
      "dateOfRegistration": "0001-01-01T00:00:00",
      "duplicate": false,
      "id": "ebbc9433-40a6-4197-902d-d4ff2efdbaa5",
      "locality": null,
      "postCode": null,
      "region": null,
      "significantParentCompanies": null,
      "significantPeople": [
        {
          "forename": "John",
          "id": "b58ec846-1da1-4ac2-be27-b1dcbff8c8dd",
          "regEntryId": null,
          "surname": "Smith"
        }
      ]
    },
    {
      "addressLine1": null,
      "companyName": "Widget Services Limited",
      "companyNumber": "23232321",
      "dateOfRegistration": "0001-01-01T00:00:00",
      "duplicate": false,
      "id": "48641603-7593-46a9-b993-8ead4daca09e",
      "locality": null,
      "postCode": null,
      "region": null,
      "significantParentCompanies": [
        {
          "addressLine1": "25 Westgate Street",
          "companyName": "Widgets International Limited",
          "companyNumber": "54345678",
          "dateOfRegistration": "1973-07-17T00:00:00",
          "duplicate": true,
          "id": "ebbc9433-40a6-4197-902d-d4ff2efdbaa5",
          "locality": "",
          "postCode": "CF101NS",
          "region": "Cardiff",
          "significantParentCompanies": null,
          "significantPeople": null
        }
      ],
      "significantPeople": null
    }
  ],
  "significantPeople": [
    {
      "forename": "John",
      "id": "108db0e1-fe11-44be-ad8f-405ed57d3fbc",
      "regEntryId": "a5d3b128-f65d-4e6d-a9e2-ac8f2763ec7a",
      "surname": "Smith"
    },
    {
      "forename": "Jane",
      "id": "965f3298-da35-4906-8d9e-d346008289dc",
      "regEntryId": null,
      "surname": "Smith"
    }
  ]
}

POST Searches for a company based on its Company Number and returns its details.

{{baseUrl}}/api/companies

HEADERS

apikey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/companies");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/companies" {:headers {:apikey ""}})

require "http/client"

url = "{{baseUrl}}/api/companies"
headers = HTTP::Headers{
  "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/companies"),
    Headers =
    {
        { "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/companies");
var request = new RestRequest("", Method.Post);
request.AddHeader("apikey", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/companies"

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

	req.Header.Add("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/companies HTTP/1.1
Apikey: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/companies")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/companies"))
    .header("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/companies")
  .post(null)
  .addHeader("apikey", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/companies")
  .header("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/companies');
xhr.setRequestHeader('apikey', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/companies',
  headers: {apikey: ''}
};

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

const url = '{{baseUrl}}/api/companies';
const options = {method: 'POST', headers: {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/companies',
  method: 'POST',
  headers: {
    apikey: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/companies")
  .post(null)
  .addHeader("apikey", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/companies',
  headers: {
    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/companies',
  headers: {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/companies');

req.headers({
  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/companies',
  headers: {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/companies';
const options = {method: 'POST', headers: {apikey: ''}};

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

#import 

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/companies"]
                                                       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/companies" in
let headers = Header.add (Header.init ()) "apikey" "" in

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

 "{{baseUrl}}/api/companies",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "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/companies', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/companies');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'apikey' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/companies');
$request->setRequestMethod('POST');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/companies' -Method POST -Headers $headers

$headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/companies' -Method POST -Headers $headers

import http.client

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

headers = { 'apikey': "" }

conn.request("POST", "/baseUrl/api/companies", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/companies"

headers = {"apikey": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/companies"

response <- VERB("POST", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/companies")

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

request = Net::HTTP::Post.new(url)
request["apikey"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/api/companies') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/companies \
  --header 'apikey: '

http POST {{baseUrl}}/api/companies \
  apikey:''

wget --quiet \
  --method POST \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/companies

import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/companies")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "addressLine1": "25 Westgate Street",
  "companyName": "Widget Production Limited",
  "companyNumber": "12345678",
  "dateOfRegistration": "1973-07-17T00:00:00",
  "duplicate": false,
  "id": "38eba446-0ff9-4602-9694-ee7f786ef9b1",
  "locality": "",
  "postCode": "CF101NS",
  "region": "Cardiff",
  "significantParentCompanies": [
    {
      "addressLine1": null,
      "companyName": "Widgets International Limited",
      "companyNumber": "54345678",
      "dateOfRegistration": "0001-01-01T00:00:00",
      "duplicate": false,
      "id": "ebbc9433-40a6-4197-902d-d4ff2efdbaa5",
      "locality": null,
      "postCode": null,
      "region": null,
      "significantParentCompanies": null,
      "significantPeople": [
        {
          "forename": "John",
          "id": "b58ec846-1da1-4ac2-be27-b1dcbff8c8dd",
          "regEntryId": null,
          "surname": "Smith"
        }
      ]
    },
    {
      "addressLine1": null,
      "companyName": "Widget Services Limited",
      "companyNumber": "23232321",
      "dateOfRegistration": "0001-01-01T00:00:00",
      "duplicate": false,
      "id": "48641603-7593-46a9-b993-8ead4daca09e",
      "locality": null,
      "postCode": null,
      "region": null,
      "significantParentCompanies": [
        {
          "addressLine1": "25 Westgate Street",
          "companyName": "Widgets International Limited",
          "companyNumber": "54345678",
          "dateOfRegistration": "1973-07-17T00:00:00",
          "duplicate": true,
          "id": "ebbc9433-40a6-4197-902d-d4ff2efdbaa5",
          "locality": "",
          "postCode": "CF101NS",
          "region": "Cardiff",
          "significantParentCompanies": null,
          "significantPeople": null
        }
      ],
      "significantPeople": null
    }
  ],
  "significantPeople": [
    {
      "forename": "John",
      "id": "108db0e1-fe11-44be-ad8f-405ed57d3fbc",
      "regEntryId": "a5d3b128-f65d-4e6d-a9e2-ac8f2763ec7a",
      "surname": "Smith"
    },
    {
      "forename": "Jane",
      "id": "965f3298-da35-4906-8d9e-d346008289dc",
      "regEntryId": null,
      "surname": "Smith"
    }
  ]
}

POST Check includes identifying bankruptcy, insolvency, CCJ's or Company Directorship.

{{baseUrl}}/api/credit-status/perform

HEADERS

apikey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/credit-status/perform");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/credit-status/perform" {:headers {:apikey ""}})

require "http/client"

url = "{{baseUrl}}/api/credit-status/perform"
headers = HTTP::Headers{
  "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/credit-status/perform"),
    Headers =
    {
        { "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/credit-status/perform");
var request = new RestRequest("", Method.Post);
request.AddHeader("apikey", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/credit-status/perform"

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

	req.Header.Add("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/credit-status/perform HTTP/1.1
Apikey: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/credit-status/perform")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/credit-status/perform"))
    .header("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/credit-status/perform")
  .post(null)
  .addHeader("apikey", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/credit-status/perform")
  .header("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/credit-status/perform');
xhr.setRequestHeader('apikey', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/credit-status/perform',
  headers: {apikey: ''}
};

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

const url = '{{baseUrl}}/api/credit-status/perform';
const options = {method: 'POST', headers: {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/credit-status/perform',
  method: 'POST',
  headers: {
    apikey: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/credit-status/perform")
  .post(null)
  .addHeader("apikey", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/credit-status/perform',
  headers: {
    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/credit-status/perform',
  headers: {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/credit-status/perform');

req.headers({
  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/credit-status/perform',
  headers: {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/credit-status/perform';
const options = {method: 'POST', headers: {apikey: ''}};

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

#import 

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/credit-status/perform"]
                                                       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/credit-status/perform" in
let headers = Header.add (Header.init ()) "apikey" "" in

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

 "{{baseUrl}}/api/credit-status/perform",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "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/credit-status/perform', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/credit-status/perform');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'apikey' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/credit-status/perform');
$request->setRequestMethod('POST');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/credit-status/perform' -Method POST -Headers $headers

$headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/credit-status/perform' -Method POST -Headers $headers

import http.client

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

headers = { 'apikey': "" }

conn.request("POST", "/baseUrl/api/credit-status/perform", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/credit-status/perform"

headers = {"apikey": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/credit-status/perform"

response <- VERB("POST", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/credit-status/perform")

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

request = Net::HTTP::Post.new(url)
request["apikey"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/api/credit-status/perform') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/credit-status/perform";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/credit-status/perform \
  --header 'apikey: '

http POST {{baseUrl}}/api/credit-status/perform \
  apikey:''

wget --quiet \
  --method POST \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/credit-status/perform

import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/credit-status/perform")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "address": null,
  "ccj": [
    {
      "address1": "Flat 30",
      "address2": "Richmond Court, St. Peters Street",
      "address3": null,
      "address4": null,
      "address5": null,
      "amount": "£5000.00",
      "caseNumber": "CS1113-56-33",
      "courtName": "CARMARTHEN COUNTY COURT",
      "dateEnd": "2017-11-09T00:00:00",
      "dob": "1988-12-04T00:00:00",
      "judgementDate": "2017-11-09T00:00:00",
      "judgementType": 2,
      "judgementTypeText": "Satisfaction",
      "name": "ANGELA ZOE SPECIMEN",
      "postcode": "CF24 3AZ"
    }
  ],
  "checkDate": "2019-08-01T12:33:11",
  "companyDirector": [
    {
      "companyAppointments": [
        {
          "address": "FLAT 30, RICHMOND COURT, ST. PETERS STREET, CARDIFF, CF24 3AZ",
          "appointmentDate": "2015-06-11T00:00:00",
          "appointmentType": "Current Director",
          "dob": "1988-12-04T00:00:00",
          "name": "Angela Zoe Specimen",
          "nationality": "British",
          "occupation": "Field Agent",
          "title": "Ms"
        }
      ],
      "companyName": "ANGELS LIMITED",
      "companyRegNo": "00123456",
      "dateAppointed": "2015-06-11T00:00:00",
      "matchType": 3,
      "matchTypeText": "Name, Address and Date of Birth",
      "registeredOffice": "FLAT 3, RICHMOND COURT, ST. PETERS STREET, CARDIFF, CF24 3AZ"
    }
  ],
  "hasBeenOverridden": false,
  "insolvency": [
    {
      "address": {
        "address1": "Flat 30",
        "address2": "Richmond Court",
        "address3": "St Peters Street",
        "address4": null,
        "address5": null,
        "dps": "DPS1",
        "isEmpty": false,
        "postcode": "CF24 3AZ"
      },
      "aliases": "ANGEL UK",
      "assetTotal": "£2000.00",
      "caseNo": "IC123456789-22232",
      "caseType": "Standard",
      "court": "CARMARTHEN COUNTY COURT",
      "debtTotal": "£20000.00",
      "description": "ANGELA ZOE SPECIMEN TRADING AS ANGELS LIMITED",
      "dob": "1988-12-04T00:00:00",
      "name": "ANGELA SPECIMEN",
      "occupation": "Field Agent",
      "presentationDate": "2018-01-15T00:00:00",
      "previousAddress": null,
      "serviceOffice": "MR JON WILLIAM JONES",
      "startDate": "2017-12-01T00:00:00",
      "status": "CURRENT",
      "telephoneNumber": "02920113244",
      "tradingNames": "ANGELS LTD",
      "type": 4,
      "typeText": "England and Wales DRO"
    }
  ],
  "person": null,
  "status": 3
}

POST Creates new data check against a specified registration.

{{baseUrl}}/api/datachecks

HEADERS

apikey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/datachecks");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/datachecks" {:headers {:apikey ""}})

require "http/client"

url = "{{baseUrl}}/api/datachecks"
headers = HTTP::Headers{
  "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/datachecks"),
    Headers =
    {
        { "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/datachecks");
var request = new RestRequest("", Method.Post);
request.AddHeader("apikey", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/datachecks"

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

	req.Header.Add("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/datachecks HTTP/1.1
Apikey: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/datachecks")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/datachecks"))
    .header("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/datachecks")
  .post(null)
  .addHeader("apikey", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/datachecks")
  .header("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/datachecks');
xhr.setRequestHeader('apikey', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/datachecks',
  headers: {apikey: ''}
};

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

const url = '{{baseUrl}}/api/datachecks';
const options = {method: 'POST', headers: {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/datachecks',
  method: 'POST',
  headers: {
    apikey: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/datachecks")
  .post(null)
  .addHeader("apikey", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/datachecks',
  headers: {
    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/datachecks',
  headers: {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/datachecks');

req.headers({
  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/datachecks',
  headers: {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/datachecks';
const options = {method: 'POST', headers: {apikey: ''}};

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

#import 

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/datachecks"]
                                                       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/datachecks" in
let headers = Header.add (Header.init ()) "apikey" "" in

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

 "{{baseUrl}}/api/datachecks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "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/datachecks', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/datachecks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'apikey' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/datachecks');
$request->setRequestMethod('POST');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/datachecks' -Method POST -Headers $headers

$headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/datachecks' -Method POST -Headers $headers

import http.client

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

headers = { 'apikey': "" }

conn.request("POST", "/baseUrl/api/datachecks", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/datachecks"

headers = {"apikey": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/datachecks"

response <- VERB("POST", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/datachecks")

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

request = Net::HTTP::Post.new(url)
request["apikey"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/api/datachecks') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/datachecks \
  --header 'apikey: '

http POST {{baseUrl}}/api/datachecks \
  apikey:''

wget --quiet \
  --method POST \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/datachecks

import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/datachecks")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "id": "abcdef12-abcd-abcd-beef-ab123cd12345",
  "regCode": "QX92TAG7"
}

POST Add a liveness image (UAP) to the specified registration.

{{baseUrl}}/api/images/liveness

HEADERS

apikey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/images/liveness");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
headers = curl_slist_append(headers, "content-type: application/*+json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/images/liveness" {:headers {:apikey ""
                                                                          :content-type "application/*+json"}})

require "http/client"

url = "{{baseUrl}}/api/images/liveness"
headers = HTTP::Headers{
  "apikey" => ""
  "content-type" => "application/*+json"
}

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/images/liveness"),
    Headers =
    {
        { "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/images/liveness");
var request = new RestRequest("", Method.Post);
request.AddHeader("apikey", "");
request.AddHeader("content-type", "application/*+json");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/images/liveness"

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

	req.Header.Add("apikey", "")
	req.Header.Add("content-type", "application/*+json")

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

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

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

}

POST /baseUrl/api/images/liveness HTTP/1.1
Apikey: 
Content-Type: application/*+json
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/images/liveness")
  .setHeader("apikey", "")
  .setHeader("content-type", "application/*+json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/images/liveness"))
    .header("apikey", "")
    .header("content-type", "application/*+json")
    .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/images/liveness")
  .post(null)
  .addHeader("apikey", "")
  .addHeader("content-type", "application/*+json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/images/liveness")
  .header("apikey", "")
  .header("content-type", "application/*+json")
  .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/images/liveness');
xhr.setRequestHeader('apikey', '');
xhr.setRequestHeader('content-type', 'application/*+json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/images/liveness',
  headers: {apikey: '', 'content-type': 'application/*+json'}
};

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

const url = '{{baseUrl}}/api/images/liveness';
const options = {method: 'POST', headers: {apikey: '', 'content-type': 'application/*+json'}};

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/images/liveness',
  method: 'POST',
  headers: {
    apikey: '',
    'content-type': 'application/*+json'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/images/liveness")
  .post(null)
  .addHeader("apikey", "")
  .addHeader("content-type", "application/*+json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/images/liveness',
  headers: {
    apikey: '',
    'content-type': 'application/*+json'
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/images/liveness',
  headers: {apikey: '', 'content-type': 'application/*+json'}
};

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/images/liveness');

req.headers({
  apikey: '',
  'content-type': 'application/*+json'
});

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/images/liveness',
  headers: {apikey: '', 'content-type': 'application/*+json'}
};

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

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

const url = '{{baseUrl}}/api/images/liveness';
const options = {method: 'POST', headers: {apikey: '', 'content-type': 'application/*+json'}};

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

#import 

NSDictionary *headers = @{ @"apikey": @"",
                           @"content-type": @"application/*+json" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/images/liveness"]
                                                       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/images/liveness" in
let headers = Header.add_list (Header.init ()) [
  ("apikey", "");
  ("content-type", "application/*+json");
] in

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

 "{{baseUrl}}/api/images/liveness",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "apikey: ",
    "content-type: application/*+json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/images/liveness', [
  'headers' => [
    'apikey' => '',
    'content-type' => 'application/*+json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/images/liveness');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'apikey' => '',
  'content-type' => 'application/*+json'
]);

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

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

setRequestUrl('{{baseUrl}}/api/images/liveness');
$request->setRequestMethod('POST');
$request->setHeaders([
  'apikey' => '',
  'content-type' => 'application/*+json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("apikey", "")
$headers.Add("content-type", "application/*+json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/images/liveness' -Method POST -Headers $headers

$headers=@{}
$headers.Add("apikey", "")
$headers.Add("content-type", "application/*+json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/images/liveness' -Method POST -Headers $headers

import http.client

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

headers = {
    'apikey': "",
    'content-type': "application/*+json"
}

conn.request("POST", "/baseUrl/api/images/liveness", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/images/liveness"

headers = {
    "apikey": "",
    "content-type": "application/*+json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/images/liveness"

response <- VERB("POST", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/images/liveness")

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

request = Net::HTTP::Post.new(url)
request["apikey"] = ''
request["content-type"] = 'application/*+json'

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/*+json'}
)

response = conn.post('/baseUrl/api/images/liveness') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/images/liveness";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("apikey", "".parse().unwrap());
    headers.insert("content-type", "application/*+json".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/images/liveness \
  --header 'apikey: ' \
  --header 'content-type: application/*+json'

http POST {{baseUrl}}/api/images/liveness \
  apikey:'' \
  content-type:'application/*+json'

wget --quiet \
  --method POST \
  --header 'apikey: ' \
  --header 'content-type: application/*+json' \
  --output-document \
  - {{baseUrl}}/api/images/liveness

import Foundation

let headers = [
  "apikey": "",
  "content-type": "application/*+json"
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/images/liveness")! 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 Add a selfie image to the registration.

{{baseUrl}}/api/images/selfie

HEADERS

apikey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/images/selfie");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/images/selfie" {:headers {:apikey ""}})

require "http/client"

url = "{{baseUrl}}/api/images/selfie"
headers = HTTP::Headers{
  "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/images/selfie"),
    Headers =
    {
        { "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/images/selfie");
var request = new RestRequest("", Method.Post);
request.AddHeader("apikey", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/images/selfie"

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

	req.Header.Add("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/images/selfie HTTP/1.1
Apikey: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/images/selfie")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/images/selfie"))
    .header("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/images/selfie")
  .post(null)
  .addHeader("apikey", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/images/selfie")
  .header("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/images/selfie');
xhr.setRequestHeader('apikey', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/images/selfie',
  headers: {apikey: ''}
};

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

const url = '{{baseUrl}}/api/images/selfie';
const options = {method: 'POST', headers: {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/images/selfie',
  method: 'POST',
  headers: {
    apikey: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/images/selfie")
  .post(null)
  .addHeader("apikey", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/images/selfie',
  headers: {
    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/images/selfie',
  headers: {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/images/selfie');

req.headers({
  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/images/selfie',
  headers: {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/images/selfie';
const options = {method: 'POST', headers: {apikey: ''}};

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

#import 

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/images/selfie"]
                                                       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/images/selfie" in
let headers = Header.add (Header.init ()) "apikey" "" in

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

 "{{baseUrl}}/api/images/selfie",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "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/images/selfie', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/images/selfie');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'apikey' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/images/selfie');
$request->setRequestMethod('POST');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/images/selfie' -Method POST -Headers $headers

$headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/images/selfie' -Method POST -Headers $headers

import http.client

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

headers = { 'apikey': "" }

conn.request("POST", "/baseUrl/api/images/selfie", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/images/selfie"

headers = {"apikey": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/images/selfie"

response <- VERB("POST", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/images/selfie")

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

request = Net::HTTP::Post.new(url)
request["apikey"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/api/images/selfie') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/images/selfie";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/images/selfie \
  --header 'apikey: '

http POST {{baseUrl}}/api/images/selfie \
  apikey:''

wget --quiet \
  --method POST \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/images/selfie

import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/images/selfie")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "livenessConfirmed": true
}

POST Add an id document image to the specified registration.

{{baseUrl}}/api/images/id-document

HEADERS

apikey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/images/id-document");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/images/id-document" {:headers {:apikey ""}})

require "http/client"

url = "{{baseUrl}}/api/images/id-document"
headers = HTTP::Headers{
  "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/images/id-document"),
    Headers =
    {
        { "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/images/id-document");
var request = new RestRequest("", Method.Post);
request.AddHeader("apikey", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/images/id-document"

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

	req.Header.Add("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/images/id-document HTTP/1.1
Apikey: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/images/id-document")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/images/id-document"))
    .header("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/images/id-document")
  .post(null)
  .addHeader("apikey", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/images/id-document")
  .header("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/images/id-document');
xhr.setRequestHeader('apikey', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/images/id-document',
  headers: {apikey: ''}
};

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

const url = '{{baseUrl}}/api/images/id-document';
const options = {method: 'POST', headers: {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/images/id-document',
  method: 'POST',
  headers: {
    apikey: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/images/id-document")
  .post(null)
  .addHeader("apikey", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/images/id-document',
  headers: {
    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/images/id-document',
  headers: {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/images/id-document');

req.headers({
  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/images/id-document',
  headers: {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/images/id-document';
const options = {method: 'POST', headers: {apikey: ''}};

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

#import 

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/images/id-document"]
                                                       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/images/id-document" in
let headers = Header.add (Header.init ()) "apikey" "" in

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

 "{{baseUrl}}/api/images/id-document",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "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/images/id-document', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/images/id-document');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'apikey' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/images/id-document');
$request->setRequestMethod('POST');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/images/id-document' -Method POST -Headers $headers

$headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/images/id-document' -Method POST -Headers $headers

import http.client

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

headers = { 'apikey': "" }

conn.request("POST", "/baseUrl/api/images/id-document", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/images/id-document"

headers = {"apikey": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/images/id-document"

response <- VERB("POST", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/images/id-document")

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

request = Net::HTTP::Post.new(url)
request["apikey"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/api/images/id-document') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/images/id-document";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/images/id-document \
  --header 'apikey: '

http POST {{baseUrl}}/api/images/id-document \
  apikey:''

wget --quiet \
  --method POST \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/images/id-document

import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/images/id-document")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "documentStatus": 1,
  "documentType": 1,
  "facialMatch": true,
  "id": "a9c10b16-130b-4051-9d60-c0c6ee9dca76",
  "regCode": "57RV4345"
}

GET Get all id document images associated with a registration.

{{baseUrl}}/api/images/id-document/:registrationId

HEADERS

apikey

QUERY PARAMS

registrationId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/images/id-document/:registrationId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/images/id-document/:registrationId" {:headers {:apikey ""}})

require "http/client"

url = "{{baseUrl}}/api/images/id-document/:registrationId"
headers = HTTP::Headers{
  "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/images/id-document/:registrationId"),
    Headers =
    {
        { "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/images/id-document/:registrationId");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/images/id-document/:registrationId"

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

	req.Header.Add("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/images/id-document/:registrationId HTTP/1.1
Apikey: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/images/id-document/:registrationId")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/images/id-document/:registrationId"))
    .header("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/images/id-document/:registrationId")
  .get()
  .addHeader("apikey", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/images/id-document/:registrationId")
  .header("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/images/id-document/:registrationId');
xhr.setRequestHeader('apikey', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/images/id-document/:registrationId',
  headers: {apikey: ''}
};

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

const url = '{{baseUrl}}/api/images/id-document/:registrationId';
const options = {method: 'GET', headers: {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/images/id-document/:registrationId',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/images/id-document/:registrationId")
  .get()
  .addHeader("apikey", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/images/id-document/:registrationId',
  headers: {
    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/images/id-document/:registrationId',
  headers: {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/images/id-document/:registrationId');

req.headers({
  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/images/id-document/:registrationId',
  headers: {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/images/id-document/:registrationId';
const options = {method: 'GET', headers: {apikey: ''}};

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

#import 

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/images/id-document/:registrationId"]
                                                       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/images/id-document/:registrationId" in
let headers = Header.add (Header.init ()) "apikey" "" in

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

 "{{baseUrl}}/api/images/id-document/:registrationId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/images/id-document/:registrationId', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/images/id-document/:registrationId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/images/id-document/:registrationId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/images/id-document/:registrationId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/images/id-document/:registrationId' -Method GET -Headers $headers

import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/images/id-document/:registrationId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/images/id-document/:registrationId"

headers = {"apikey": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/images/id-document/:registrationId"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/images/id-document/:registrationId")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/api/images/id-document/:registrationId') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/images/id-document/:registrationId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/images/id-document/:registrationId \
  --header 'apikey: '

http GET {{baseUrl}}/api/images/id-document/:registrationId \
  apikey:''

wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/images/id-document/:registrationId

import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/images/id-document/:registrationId")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "addressCity": null,
    "addressFull": null,
    "addressPostcode": null,
    "country": "United Kingdom",
    "countryCode": "GBR",
    "dateCreated": "2018-02-23T17:22:11.044",
    "dateOfBirth": "1968-11-23T00:00:00",
    "description": "Passport",
    "documentAnalysisResult": 1,
    "documentNumber": "123456789",
    "documentSide": 1,
    "expiryDate": "2025-04-21T00:00:00",
    "facialMatch": true,
    "forename": "Alan",
    "fullName": "Alan Harper",
    "hiResUrl": "https://",
    "id": "fedcba89-dead-1278-bead-8901234abcde",
    "isUnderReview": false,
    "manuallyVerified": false,
    "middleName": "William",
    "mrz1": "P


                        
                            
                                
                                    
                                        
                                            GET
                                            Retrieve the liveness action image (UAP) associated with a registration.
                                        
                                    

                                    {{baseUrl}}/api/images/liveness/:registrationId


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            registrationId
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/images/liveness/:registrationId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/images/liveness/:registrationId" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/images/liveness/:registrationId"
headers = HTTP::Headers{
  "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/images/liveness/:registrationId"),
    Headers =
    {
        { "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/images/liveness/:registrationId");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/images/liveness/:registrationId"

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

	req.Header.Add("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/images/liveness/:registrationId HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/images/liveness/:registrationId")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/images/liveness/:registrationId"))
    .header("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/images/liveness/:registrationId")
  .get()
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.get("{{baseUrl}}/api/images/liveness/:registrationId")
  .header("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/images/liveness/:registrationId');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/images/liveness/:registrationId',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/images/liveness/:registrationId';
const options = {method: 'GET', headers: {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/images/liveness/:registrationId',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/images/liveness/:registrationId")
  .get()
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/images/liveness/:registrationId',
  headers: {
    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/images/liveness/:registrationId',
  headers: {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/images/liveness/:registrationId');

req.headers({
  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/images/liveness/:registrationId',
  headers: {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/images/liveness/:registrationId';
const options = {method: 'GET', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/images/liveness/:registrationId"]
                                                       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/images/liveness/:registrationId" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/images/liveness/:registrationId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/images/liveness/:registrationId', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/images/liveness/:registrationId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/images/liveness/:registrationId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/images/liveness/:registrationId' -Method GET -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/images/liveness/:registrationId' -Method GET -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/images/liveness/:registrationId", headers=headers)

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

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

url = "{{baseUrl}}/api/images/liveness/:registrationId"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/images/liveness/:registrationId"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/images/liveness/:registrationId")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.get('/baseUrl/api/images/liveness/:registrationId') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/images/liveness/:registrationId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/images/liveness/:registrationId \
  --header 'apikey: '
                                            
                                            
                                                http GET {{baseUrl}}/api/images/liveness/:registrationId \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/images/liveness/:registrationId
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/images/liveness/:registrationId")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                {
  "description": "Touch your LEFT cheek with your LEFT hand",
  "id": "afbaa1d2-d81a-415d-bc51-092651c84bbb",
  "url": "https://example.com/image.jpg"
}
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            GET
                                            Retrieve the liveness performed image associated with a registration.
                                        
                                    

                                    {{baseUrl}}/api/images/liveness-performed/:registrationId


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            registrationId
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/images/liveness-performed/:registrationId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/images/liveness-performed/:registrationId" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/images/liveness-performed/:registrationId"
headers = HTTP::Headers{
  "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/images/liveness-performed/:registrationId"),
    Headers =
    {
        { "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/images/liveness-performed/:registrationId");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/images/liveness-performed/:registrationId"

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

	req.Header.Add("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/images/liveness-performed/:registrationId HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/images/liveness-performed/:registrationId")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/images/liveness-performed/:registrationId"))
    .header("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/images/liveness-performed/:registrationId")
  .get()
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.get("{{baseUrl}}/api/images/liveness-performed/:registrationId")
  .header("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/images/liveness-performed/:registrationId');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/images/liveness-performed/:registrationId',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/images/liveness-performed/:registrationId';
const options = {method: 'GET', headers: {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/images/liveness-performed/:registrationId',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/images/liveness-performed/:registrationId")
  .get()
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/images/liveness-performed/:registrationId',
  headers: {
    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/images/liveness-performed/:registrationId',
  headers: {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/images/liveness-performed/:registrationId');

req.headers({
  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/images/liveness-performed/:registrationId',
  headers: {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/images/liveness-performed/:registrationId';
const options = {method: 'GET', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/images/liveness-performed/:registrationId"]
                                                       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/images/liveness-performed/:registrationId" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/images/liveness-performed/:registrationId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/images/liveness-performed/:registrationId', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/images/liveness-performed/:registrationId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/images/liveness-performed/:registrationId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/images/liveness-performed/:registrationId' -Method GET -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/images/liveness-performed/:registrationId' -Method GET -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/images/liveness-performed/:registrationId", headers=headers)

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

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

url = "{{baseUrl}}/api/images/liveness-performed/:registrationId"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/images/liveness-performed/:registrationId"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/images/liveness-performed/:registrationId")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.get('/baseUrl/api/images/liveness-performed/:registrationId') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/images/liveness-performed/:registrationId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/images/liveness-performed/:registrationId \
  --header 'apikey: '
                                            
                                            
                                                http GET {{baseUrl}}/api/images/liveness-performed/:registrationId \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/images/liveness-performed/:registrationId
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/images/liveness-performed/:registrationId")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                {
  "base64Data": null,
  "url": "https://url.to/a/liveness-performed/image.jpg"
}
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            GET
                                            Retrieve the selfie image associated with a registration.
                                        
                                    

                                    {{baseUrl}}/api/images/selfie/:registrationId


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            registrationId
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/images/selfie/:registrationId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/images/selfie/:registrationId" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/images/selfie/:registrationId"
headers = HTTP::Headers{
  "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/images/selfie/:registrationId"),
    Headers =
    {
        { "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/images/selfie/:registrationId");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/images/selfie/:registrationId"

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

	req.Header.Add("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/images/selfie/:registrationId HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/images/selfie/:registrationId")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/images/selfie/:registrationId"))
    .header("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/images/selfie/:registrationId")
  .get()
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.get("{{baseUrl}}/api/images/selfie/:registrationId")
  .header("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/images/selfie/:registrationId');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/images/selfie/:registrationId',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/images/selfie/:registrationId';
const options = {method: 'GET', headers: {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/images/selfie/:registrationId',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/images/selfie/:registrationId")
  .get()
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/images/selfie/:registrationId',
  headers: {
    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/images/selfie/:registrationId',
  headers: {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/images/selfie/:registrationId');

req.headers({
  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/images/selfie/:registrationId',
  headers: {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/images/selfie/:registrationId';
const options = {method: 'GET', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/images/selfie/:registrationId"]
                                                       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/images/selfie/:registrationId" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/images/selfie/:registrationId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/images/selfie/:registrationId', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/images/selfie/:registrationId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/images/selfie/:registrationId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/images/selfie/:registrationId' -Method GET -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/images/selfie/:registrationId' -Method GET -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/images/selfie/:registrationId", headers=headers)

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

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

url = "{{baseUrl}}/api/images/selfie/:registrationId"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/images/selfie/:registrationId"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/images/selfie/:registrationId")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.get('/baseUrl/api/images/selfie/:registrationId') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/images/selfie/:registrationId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/images/selfie/:registrationId \
  --header 'apikey: '
                                            
                                            
                                                http GET {{baseUrl}}/api/images/selfie/:registrationId \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/images/selfie/:registrationId
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/images/selfie/:registrationId")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                {
  "base64Data": null,
  "url": "https://url.to/a/selfie/image.jpg"
}
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            GET
                                            Returns a detailed report on the analysis that has taken place of a scanned document
                                        
                                    

                                    {{baseUrl}}/api/images/scan-report-pdf/:scanId


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            scanId
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/images/scan-report-pdf/:scanId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/images/scan-report-pdf/:scanId" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/images/scan-report-pdf/:scanId"
headers = HTTP::Headers{
  "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/images/scan-report-pdf/:scanId"),
    Headers =
    {
        { "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/images/scan-report-pdf/:scanId");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/images/scan-report-pdf/:scanId"

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

	req.Header.Add("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/images/scan-report-pdf/:scanId HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/images/scan-report-pdf/:scanId")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/images/scan-report-pdf/:scanId"))
    .header("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/images/scan-report-pdf/:scanId")
  .get()
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.get("{{baseUrl}}/api/images/scan-report-pdf/:scanId")
  .header("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/images/scan-report-pdf/:scanId');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/images/scan-report-pdf/:scanId',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/images/scan-report-pdf/:scanId';
const options = {method: 'GET', headers: {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/images/scan-report-pdf/:scanId',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/images/scan-report-pdf/:scanId")
  .get()
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/images/scan-report-pdf/:scanId',
  headers: {
    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/images/scan-report-pdf/:scanId',
  headers: {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/images/scan-report-pdf/:scanId');

req.headers({
  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/images/scan-report-pdf/:scanId',
  headers: {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/images/scan-report-pdf/:scanId';
const options = {method: 'GET', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/images/scan-report-pdf/:scanId"]
                                                       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/images/scan-report-pdf/:scanId" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/images/scan-report-pdf/:scanId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/images/scan-report-pdf/:scanId', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/images/scan-report-pdf/:scanId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/images/scan-report-pdf/:scanId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/images/scan-report-pdf/:scanId' -Method GET -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/images/scan-report-pdf/:scanId' -Method GET -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/images/scan-report-pdf/:scanId", headers=headers)

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

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

url = "{{baseUrl}}/api/images/scan-report-pdf/:scanId"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/images/scan-report-pdf/:scanId"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/images/scan-report-pdf/:scanId")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.get('/baseUrl/api/images/scan-report-pdf/:scanId') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/images/scan-report-pdf/:scanId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/images/scan-report-pdf/:scanId \
  --header 'apikey: '
                                            
                                            
                                                http GET {{baseUrl}}/api/images/scan-report-pdf/:scanId \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/images/scan-report-pdf/:scanId
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/images/scan-report-pdf/:scanId")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                ZGVmZ2hp
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            POST
                                            Creates new property registry check against the registration.
                                        
                                    

                                    {{baseUrl}}/api/property-register


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    


                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/property-register");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/property-register" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/property-register"
headers = HTTP::Headers{
  "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/property-register"),
    Headers =
    {
        { "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/property-register");
var request = new RestRequest("", Method.Post);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/property-register"

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

	req.Header.Add("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/property-register HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/property-register")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/property-register"))
    .header("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/property-register")
  .post(null)
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.post("{{baseUrl}}/api/property-register")
  .header("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/property-register');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/property-register',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/property-register';
const options = {method: 'POST', headers: {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/property-register',
  method: 'POST',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/property-register")
  .post(null)
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/property-register',
  headers: {
    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/property-register',
  headers: {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/property-register');

req.headers({
  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/property-register',
  headers: {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/property-register';
const options = {method: 'POST', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/property-register"]
                                                       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/property-register" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/property-register",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "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/property-register', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/property-register');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/property-register');
$request->setRequestMethod('POST');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/property-register' -Method POST -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/property-register' -Method POST -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("POST", "/baseUrl/api/property-register", headers=headers)

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

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

url = "{{baseUrl}}/api/property-register"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/property-register"

response <- VERB("POST", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/property-register")

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

request = Net::HTTP::Post.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.post('/baseUrl/api/property-register') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/property-register";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/property-register \
  --header 'apikey: '
                                            
                                            
                                                http POST {{baseUrl}}/api/property-register \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method POST \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/property-register
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/property-register")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                {
  "checkStatus": 1,
  "hasBeenOverridden": false,
  "matchResult": 1,
  "matchResultText": "Full Name Match",
  "propertyOwnership": 2,
  "propertyOwnershipText": "Joint Ownership",
  "titleNumber": "TMP123456"
}
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            GET
                                            Retrieves property registry check associated with the registration.
                                        
                                    

                                    {{baseUrl}}/api/property-register/:id


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            id
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/property-register/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/property-register/:id" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/property-register/:id"
headers = HTTP::Headers{
  "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/property-register/:id"),
    Headers =
    {
        { "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/property-register/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/property-register/:id"

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

	req.Header.Add("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/property-register/:id HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/property-register/:id")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/property-register/:id"))
    .header("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/property-register/:id")
  .get()
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.get("{{baseUrl}}/api/property-register/:id")
  .header("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/property-register/:id');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/property-register/:id',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/property-register/:id';
const options = {method: 'GET', headers: {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/property-register/:id',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/property-register/:id")
  .get()
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/property-register/:id',
  headers: {
    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/property-register/:id',
  headers: {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/property-register/:id');

req.headers({
  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/property-register/:id',
  headers: {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/property-register/:id';
const options = {method: 'GET', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/property-register/: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/property-register/:id" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/property-register/: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 => [
    "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/property-register/:id', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/property-register/:id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/property-register/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/property-register/:id' -Method GET -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/property-register/:id' -Method GET -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/property-register/:id", headers=headers)

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

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

url = "{{baseUrl}}/api/property-register/:id"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/property-register/:id"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/property-register/:id")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.get('/baseUrl/api/property-register/:id') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/property-register/:id \
  --header 'apikey: '
                                            
                                            
                                                http GET {{baseUrl}}/api/property-register/:id \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/property-register/:id
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/property-register/: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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                {
  "checkStatus": 1,
  "hasBeenOverridden": false,
  "matchResult": 1,
  "matchResultText": "Full Name Match",
  "propertyOwnership": 2,
  "propertyOwnershipText": "Joint Ownership",
  "titleNumber": "TMP123456"
}
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            GET
                                            Checks if submitted documents are sufficient to complete registration.
                                        
                                    

                                    {{baseUrl}}/api/registrations/:id/check-submitted-id-documents


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            id
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations/:id/check-submitted-id-documents");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/registrations/:id/check-submitted-id-documents" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations/:id/check-submitted-id-documents"
headers = HTTP::Headers{
  "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/registrations/:id/check-submitted-id-documents"),
    Headers =
    {
        { "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/registrations/:id/check-submitted-id-documents");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations/:id/check-submitted-id-documents"

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

	req.Header.Add("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/registrations/:id/check-submitted-id-documents HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/registrations/:id/check-submitted-id-documents")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations/:id/check-submitted-id-documents"))
    .header("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/registrations/:id/check-submitted-id-documents")
  .get()
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.get("{{baseUrl}}/api/registrations/:id/check-submitted-id-documents")
  .header("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/registrations/:id/check-submitted-id-documents');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/registrations/:id/check-submitted-id-documents',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations/:id/check-submitted-id-documents';
const options = {method: 'GET', headers: {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/registrations/:id/check-submitted-id-documents',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations/:id/check-submitted-id-documents")
  .get()
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations/:id/check-submitted-id-documents',
  headers: {
    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/registrations/:id/check-submitted-id-documents',
  headers: {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/registrations/:id/check-submitted-id-documents');

req.headers({
  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/registrations/:id/check-submitted-id-documents',
  headers: {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/registrations/:id/check-submitted-id-documents';
const options = {method: 'GET', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations/:id/check-submitted-id-documents"]
                                                       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/registrations/:id/check-submitted-id-documents" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations/:id/check-submitted-id-documents",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/registrations/:id/check-submitted-id-documents', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations/:id/check-submitted-id-documents');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations/:id/check-submitted-id-documents');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations/:id/check-submitted-id-documents' -Method GET -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations/:id/check-submitted-id-documents' -Method GET -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/registrations/:id/check-submitted-id-documents", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations/:id/check-submitted-id-documents"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations/:id/check-submitted-id-documents"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations/:id/check-submitted-id-documents")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.get('/baseUrl/api/registrations/:id/check-submitted-id-documents') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/registrations/:id/check-submitted-id-documents";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/registrations/:id/check-submitted-id-documents \
  --header 'apikey: '
                                            
                                            
                                                http GET {{baseUrl}}/api/registrations/:id/check-submitted-id-documents \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/registrations/:id/check-submitted-id-documents
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations/:id/check-submitted-id-documents")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                {
  "checkCode": 3,
  "message": "Please provide proof of address."
}
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            POST
                                            Creates new registration record, adds an ID document and optional selfie image in one go.
                                        
                                    

                                    {{baseUrl}}/api/registrations/instant


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    


                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations/instant");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/registrations/instant" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations/instant"
headers = HTTP::Headers{
  "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/registrations/instant"),
    Headers =
    {
        { "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/registrations/instant");
var request = new RestRequest("", Method.Post);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations/instant"

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

	req.Header.Add("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/registrations/instant HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/registrations/instant")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations/instant"))
    .header("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/registrations/instant")
  .post(null)
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.post("{{baseUrl}}/api/registrations/instant")
  .header("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/registrations/instant');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/registrations/instant',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations/instant';
const options = {method: 'POST', headers: {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/registrations/instant',
  method: 'POST',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations/instant")
  .post(null)
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations/instant',
  headers: {
    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/registrations/instant',
  headers: {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/registrations/instant');

req.headers({
  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/registrations/instant',
  headers: {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/registrations/instant';
const options = {method: 'POST', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations/instant"]
                                                       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/registrations/instant" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations/instant",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "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/registrations/instant', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations/instant');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations/instant');
$request->setRequestMethod('POST');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations/instant' -Method POST -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations/instant' -Method POST -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("POST", "/baseUrl/api/registrations/instant", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations/instant"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations/instant"

response <- VERB("POST", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations/instant")

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

request = Net::HTTP::Post.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.post('/baseUrl/api/registrations/instant') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/registrations/instant";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/registrations/instant \
  --header 'apikey: '
                                            
                                            
                                                http POST {{baseUrl}}/api/registrations/instant \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method POST \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/registrations/instant
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations/instant")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                {
  "documentStatus": 1,
  "documentType": 1,
  "facialMatch": true,
  "id": "abcdef12-abcd-abcd-beef-ab123cd12345",
  "regCode": "QX92TAG7"
}
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            POST
                                            Creates new registration.
                                        
                                    

                                    {{baseUrl}}/api/registrations


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    


                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/registrations" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations"
headers = HTTP::Headers{
  "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/registrations"),
    Headers =
    {
        { "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/registrations");
var request = new RestRequest("", Method.Post);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations"

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

	req.Header.Add("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/registrations HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/registrations")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations"))
    .header("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/registrations")
  .post(null)
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.post("{{baseUrl}}/api/registrations")
  .header("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/registrations');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/registrations',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations';
const options = {method: 'POST', headers: {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/registrations',
  method: 'POST',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations")
  .post(null)
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations',
  headers: {
    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/registrations',
  headers: {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/registrations');

req.headers({
  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/registrations',
  headers: {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/registrations';
const options = {method: 'POST', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations"]
                                                       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/registrations" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "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/registrations', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations');
$request->setRequestMethod('POST');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations' -Method POST -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations' -Method POST -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("POST", "/baseUrl/api/registrations", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations"

response <- VERB("POST", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations")

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

request = Net::HTTP::Post.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.post('/baseUrl/api/registrations') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/registrations \
  --header 'apikey: '
                                            
                                            
                                                http POST {{baseUrl}}/api/registrations \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method POST \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/registrations
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                {
  "id": "abcdef12-abcd-abcd-beef-ab123cd12345",
  "regCode": "QX92TAG7",
  "webJourneyUrl": {
    "url": "https://pi-verify.credas.co.uk/link/f7ec8ac1-d935-413b-9100-c7b9b498ca1d",
    "validUntil": "2023-03-06T07:31:35.7814067Z"
  }
}
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            GET
                                            Finds a registration by the Id.
                                        
                                    

                                    {{baseUrl}}/api/registrations/:id/summary


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            id
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations/:id/summary");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/registrations/:id/summary" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations/:id/summary"
headers = HTTP::Headers{
  "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/registrations/:id/summary"),
    Headers =
    {
        { "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/registrations/:id/summary");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations/:id/summary"

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

	req.Header.Add("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/registrations/:id/summary HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/registrations/:id/summary")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations/:id/summary"))
    .header("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/registrations/:id/summary")
  .get()
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.get("{{baseUrl}}/api/registrations/:id/summary")
  .header("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/registrations/:id/summary');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/registrations/:id/summary',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations/:id/summary';
const options = {method: 'GET', headers: {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/registrations/:id/summary',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations/:id/summary")
  .get()
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations/:id/summary',
  headers: {
    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/registrations/:id/summary',
  headers: {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/registrations/:id/summary');

req.headers({
  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/registrations/:id/summary',
  headers: {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/registrations/:id/summary';
const options = {method: 'GET', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations/:id/summary"]
                                                       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/registrations/:id/summary" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations/:id/summary",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/registrations/:id/summary', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations/:id/summary');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations/:id/summary');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations/:id/summary' -Method GET -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations/:id/summary' -Method GET -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/registrations/:id/summary", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations/:id/summary"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations/:id/summary"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations/:id/summary")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.get('/baseUrl/api/registrations/:id/summary') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/registrations/:id/summary";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/registrations/:id/summary \
  --header 'apikey: '
                                            
                                            
                                                http GET {{baseUrl}}/api/registrations/:id/summary \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/registrations/:id/summary
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations/:id/summary")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                {
  "Comments": null,
  "DITFDate": null,
  "DITFStatus": 0,
  "bankAccountChecks": [
    {
      "Address1": null,
      "City": null,
      "Forename": null,
      "MiddleName": null,
      "PostCode": null,
      "Surname": null,
      "accountNumber": "12345678",
      "accountNumberValidation": 2,
      "accountNumberValidationText": "Valid",
      "accountStatus": 2,
      "accountStatusText": "Live",
      "accountValid": true,
      "addressValidation": 2,
      "addressValidationText": "Current address",
      "checkDate": "2019-08-01T12:15:22",
      "checkId": "12345678-1234-5678-abcd-1234567890ab",
      "checkStatus": 1,
      "error": false,
      "hasBeenOverridden": false,
      "nameValidation": 2,
      "nameValidationText": "Valid",
      "referenceId": "RF1234",
      "sortcode": "123456",
      "sortcodeValidation": 2,
      "sortcodeValidationText": "Valid"
    }
  ],
  "createdByAgencyUserId": null,
  "creditStatusCheck": {
    "address": null,
    "ccj": [
      {
        "address1": "Flat 30",
        "address2": "Richmond Court, St. Peters Street",
        "address3": null,
        "address4": null,
        "address5": null,
        "amount": "£5000.00",
        "caseNumber": "CS1113-56-33",
        "courtName": "CARMARTHEN COUNTY COURT",
        "dateEnd": "2017-11-09T00:00:00",
        "dob": "1988-12-04T00:00:00",
        "judgementDate": "2017-11-09T00:00:00",
        "judgementType": 2,
        "judgementTypeText": "Satisfaction",
        "name": "ANGELA ZOE SPECIMEN",
        "postcode": "CF24 3AZ"
      }
    ],
    "checkDate": "2019-08-01T12:33:11",
    "companyDirector": [
      {
        "companyAppointments": [
          {
            "address": "FLAT 30, RICHMOND COURT, ST. PETERS STREET, CARDIFF, CF24 3AZ",
            "appointmentDate": "2015-06-11T00:00:00",
            "appointmentType": "Current Director",
            "dob": "1988-12-04T00:00:00",
            "name": "Angela Zoe Specimen",
            "nationality": "British",
            "occupation": "Field Agent",
            "title": "Ms"
          }
        ],
        "companyName": "ANGELS LIMITED",
        "companyRegNo": "00123456",
        "dateAppointed": "2015-06-11T00:00:00",
        "matchType": 3,
        "matchTypeText": "Name, Address and Date of Birth",
        "registeredOffice": "FLAT 3, RICHMOND COURT, ST. PETERS STREET, CARDIFF, CF24 3AZ"
      }
    ],
    "hasBeenOverridden": false,
    "insolvency": [
      {
        "address": {
          "address1": "Flat 30",
          "address2": "Richmond Court",
          "address3": "St Peters Street",
          "address4": null,
          "address5": null,
          "dps": "DPS1",
          "isEmpty": false,
          "postcode": "CF24 3AZ"
        },
        "aliases": "ANGEL UK",
        "assetTotal": "£2000.00",
        "caseNo": "IC123456789-22232",
        "caseType": "Standard",
        "court": "CARMARTHEN COUNTY COURT",
        "debtTotal": "£20000.00",
        "description": "ANGELA ZOE SPECIMEN TRADING AS ANGELS LIMITED",
        "dob": "1988-12-04T00:00:00",
        "name": "ANGELA SPECIMEN",
        "occupation": "Field Agent",
        "presentationDate": "2018-01-15T00:00:00",
        "previousAddress": null,
        "serviceOffice": "MR JON WILLIAM JONES",
        "startDate": "2017-12-01T00:00:00",
        "status": "CURRENT",
        "telephoneNumber": "02920113244",
        "tradingNames": "ANGELS LTD",
        "type": 4,
        "typeText": "England and Wales DRO"
      }
    ],
    "person": null,
    "status": 3
  },
  "customTermsAccepted": false,
  "customTermsAcceptedDateTime": null,
  "customTermsAcceptedVersion": null,
  "dataCheckResult": 1,
  "dataCheckSources": [
    {
      "address": null,
      "dateCreated": "2018-02-23T12:54:32.017",
      "hasBeenOverridden": false,
      "hasPepSanctionsData": false,
      "label": "Mortality",
      "pepSanctionsData": null,
      "person": null,
      "remarks": [
        {
          "category": 1,
          "description": "Halo source indicates this person is not deceased at address 1"
        },
        {
          "category": 4,
          "description": "No middle initial specified by user"
        }
      ],
      "sourceType": 3,
      "status": 1
    },
    {
      "address": null,
      "dateCreated": "2018-02-23T12:54:32.017",
      "hasBeenOverridden": false,
      "hasPepSanctionsData": false,
      "label": "Address and DOB",
      "pepSanctionsData": null,
      "person": null,
      "remarks": [
        {
          "category": 1,
          "description": "(Electoral Register) Address #1 details are valid"
        },
        {
          "category": 2,
          "description": "(Electoral Register) Surname details not matched address #1"
        }
      ],
      "sourceType": 4,
      "status": 2
    },
    {
      "address": null,
      "dateCreated": "2018-02-23T12:54:32.017",
      "hasBeenOverridden": false,
      "hasPepSanctionsData": true,
      "label": "International Sanctions",
      "pepSanctionsData": [
        {
          "addresses": [
            {
              "lines": [
                "44 Lowbridge Street",
                "Pasadena",
                "California",
                "USA"
              ]
            }
          ],
          "aliases": null,
          "fullName": "Alan Stuart Harper",
          "id": null,
          "positions": [
            {
              "country": "USA",
              "position": "Head of local gov"
            }
          ],
          "sanctionBodies": null,
          "sanctionDates": [
            {
              "date": "1937-04-03T12:00:00Z",
              "day": 3,
              "month": 4,
              "type": 1,
              "year": 1937
            }
          ]
        }
      ],
      "person": null,
      "remarks": [
        {
          "category": 1,
          "description": "Full name has not been matched."
        }
      ],
      "sourceType": 7,
      "status": 1
    }
  ],
  "dataChecksPerformed": true,
  "dateCompleted": null,
  "dateCreated": "2018-02-23T12:54:31.611",
  "email": "alan.harper@email.com",
  "forename": "Alan",
  "hasLivenessPerformed": false,
  "hasSelfie": false,
  "id": "abcdef12-abcd-abcd-beef-ab123cd12345",
  "idDocuments": [
    {
      "addressCity": null,
      "addressFull": null,
      "addressPostcode": null,
      "country": "United Kingdom",
      "countryCode": "GBR",
      "dateCreated": "2018-02-23T17:22:11.044",
      "dateOfBirth": "1968-11-23T00:00:00",
      "description": "Passport",
      "documentAnalysisResult": 1,
      "documentNumber": "123456789",
      "documentSide": 1,
      "expiryDate": "2025-04-21T00:00:00",
      "facialMatch": true,
      "forename": "Alan",
      "fullName": "Alan Harper",
      "id": "fedcba89-dead-1278-bead-8901234abcde",
      "isUnderReview": false,
      "manuallyVerified": false,
      "middleName": "William",
      "mrz1": "P

                                            

                                        

                                    

                                

                            

                        

                        
                            
                                
                                    
                                        
                                            GET
                                            Finds a registration by the RegCode.
                                        
                                    

                                    {{baseUrl}}/api/registrations/regcode/:regCode/summary


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            regCode
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations/regcode/:regCode/summary");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/registrations/regcode/:regCode/summary" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations/regcode/:regCode/summary"
headers = HTTP::Headers{
  "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/registrations/regcode/:regCode/summary"),
    Headers =
    {
        { "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/registrations/regcode/:regCode/summary");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations/regcode/:regCode/summary"

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

	req.Header.Add("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/registrations/regcode/:regCode/summary HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/registrations/regcode/:regCode/summary")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations/regcode/:regCode/summary"))
    .header("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/registrations/regcode/:regCode/summary")
  .get()
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.get("{{baseUrl}}/api/registrations/regcode/:regCode/summary")
  .header("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/registrations/regcode/:regCode/summary');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/registrations/regcode/:regCode/summary',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations/regcode/:regCode/summary';
const options = {method: 'GET', headers: {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/registrations/regcode/:regCode/summary',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations/regcode/:regCode/summary")
  .get()
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations/regcode/:regCode/summary',
  headers: {
    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/registrations/regcode/:regCode/summary',
  headers: {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/registrations/regcode/:regCode/summary');

req.headers({
  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/registrations/regcode/:regCode/summary',
  headers: {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/registrations/regcode/:regCode/summary';
const options = {method: 'GET', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations/regcode/:regCode/summary"]
                                                       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/registrations/regcode/:regCode/summary" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations/regcode/:regCode/summary",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/registrations/regcode/:regCode/summary', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations/regcode/:regCode/summary');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations/regcode/:regCode/summary');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations/regcode/:regCode/summary' -Method GET -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations/regcode/:regCode/summary' -Method GET -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/registrations/regcode/:regCode/summary", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations/regcode/:regCode/summary"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations/regcode/:regCode/summary"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations/regcode/:regCode/summary")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.get('/baseUrl/api/registrations/regcode/:regCode/summary') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/registrations/regcode/:regCode/summary";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/registrations/regcode/:regCode/summary \
  --header 'apikey: '
                                            
                                            
                                                http GET {{baseUrl}}/api/registrations/regcode/:regCode/summary \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/registrations/regcode/:regCode/summary
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations/regcode/:regCode/summary")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                {
  "Comments": null,
  "DITFDate": null,
  "DITFStatus": 0,
  "bankAccountChecks": [
    {
      "Address1": null,
      "City": null,
      "Forename": null,
      "MiddleName": null,
      "PostCode": null,
      "Surname": null,
      "accountNumber": "12345678",
      "accountNumberValidation": 2,
      "accountNumberValidationText": "Valid",
      "accountStatus": 2,
      "accountStatusText": "Live",
      "accountValid": true,
      "addressValidation": 2,
      "addressValidationText": "Current address",
      "checkDate": "2019-08-01T12:15:22",
      "checkId": "12345678-1234-5678-abcd-1234567890ab",
      "checkStatus": 1,
      "error": false,
      "hasBeenOverridden": false,
      "nameValidation": 2,
      "nameValidationText": "Valid",
      "referenceId": "RF1234",
      "sortcode": "123456",
      "sortcodeValidation": 2,
      "sortcodeValidationText": "Valid"
    }
  ],
  "createdByAgencyUserId": null,
  "creditStatusCheck": {
    "address": null,
    "ccj": [
      {
        "address1": "Flat 30",
        "address2": "Richmond Court, St. Peters Street",
        "address3": null,
        "address4": null,
        "address5": null,
        "amount": "£5000.00",
        "caseNumber": "CS1113-56-33",
        "courtName": "CARMARTHEN COUNTY COURT",
        "dateEnd": "2017-11-09T00:00:00",
        "dob": "1988-12-04T00:00:00",
        "judgementDate": "2017-11-09T00:00:00",
        "judgementType": 2,
        "judgementTypeText": "Satisfaction",
        "name": "ANGELA ZOE SPECIMEN",
        "postcode": "CF24 3AZ"
      }
    ],
    "checkDate": "2019-08-01T12:33:11",
    "companyDirector": [
      {
        "companyAppointments": [
          {
            "address": "FLAT 30, RICHMOND COURT, ST. PETERS STREET, CARDIFF, CF24 3AZ",
            "appointmentDate": "2015-06-11T00:00:00",
            "appointmentType": "Current Director",
            "dob": "1988-12-04T00:00:00",
            "name": "Angela Zoe Specimen",
            "nationality": "British",
            "occupation": "Field Agent",
            "title": "Ms"
          }
        ],
        "companyName": "ANGELS LIMITED",
        "companyRegNo": "00123456",
        "dateAppointed": "2015-06-11T00:00:00",
        "matchType": 3,
        "matchTypeText": "Name, Address and Date of Birth",
        "registeredOffice": "FLAT 3, RICHMOND COURT, ST. PETERS STREET, CARDIFF, CF24 3AZ"
      }
    ],
    "hasBeenOverridden": false,
    "insolvency": [
      {
        "address": {
          "address1": "Flat 30",
          "address2": "Richmond Court",
          "address3": "St Peters Street",
          "address4": null,
          "address5": null,
          "dps": "DPS1",
          "isEmpty": false,
          "postcode": "CF24 3AZ"
        },
        "aliases": "ANGEL UK",
        "assetTotal": "£2000.00",
        "caseNo": "IC123456789-22232",
        "caseType": "Standard",
        "court": "CARMARTHEN COUNTY COURT",
        "debtTotal": "£20000.00",
        "description": "ANGELA ZOE SPECIMEN TRADING AS ANGELS LIMITED",
        "dob": "1988-12-04T00:00:00",
        "name": "ANGELA SPECIMEN",
        "occupation": "Field Agent",
        "presentationDate": "2018-01-15T00:00:00",
        "previousAddress": null,
        "serviceOffice": "MR JON WILLIAM JONES",
        "startDate": "2017-12-01T00:00:00",
        "status": "CURRENT",
        "telephoneNumber": "02920113244",
        "tradingNames": "ANGELS LTD",
        "type": 4,
        "typeText": "England and Wales DRO"
      }
    ],
    "person": null,
    "status": 3
  },
  "customTermsAccepted": false,
  "customTermsAcceptedDateTime": null,
  "customTermsAcceptedVersion": null,
  "dataCheckResult": 1,
  "dataCheckSources": [
    {
      "address": null,
      "dateCreated": "2018-02-23T12:54:32.017",
      "hasBeenOverridden": false,
      "hasPepSanctionsData": false,
      "label": "Mortality",
      "pepSanctionsData": null,
      "person": null,
      "remarks": [
        {
          "category": 1,
          "description": "Halo source indicates this person is not deceased at address 1"
        },
        {
          "category": 4,
          "description": "No middle initial specified by user"
        }
      ],
      "sourceType": 3,
      "status": 1
    },
    {
      "address": null,
      "dateCreated": "2018-02-23T12:54:32.017",
      "hasBeenOverridden": false,
      "hasPepSanctionsData": false,
      "label": "Address and DOB",
      "pepSanctionsData": null,
      "person": null,
      "remarks": [
        {
          "category": 1,
          "description": "(Electoral Register) Address #1 details are valid"
        },
        {
          "category": 2,
          "description": "(Electoral Register) Surname details not matched address #1"
        }
      ],
      "sourceType": 4,
      "status": 2
    },
    {
      "address": null,
      "dateCreated": "2018-02-23T12:54:32.017",
      "hasBeenOverridden": false,
      "hasPepSanctionsData": true,
      "label": "International Sanctions",
      "pepSanctionsData": [
        {
          "addresses": [
            {
              "lines": [
                "44 Lowbridge Street",
                "Pasadena",
                "California",
                "USA"
              ]
            }
          ],
          "aliases": null,
          "fullName": "Alan Stuart Harper",
          "id": null,
          "positions": [
            {
              "country": "USA",
              "position": "Head of local gov"
            }
          ],
          "sanctionBodies": null,
          "sanctionDates": [
            {
              "date": "1937-04-03T12:00:00Z",
              "day": 3,
              "month": 4,
              "type": 1,
              "year": 1937
            }
          ]
        }
      ],
      "person": null,
      "remarks": [
        {
          "category": 1,
          "description": "Full name has not been matched."
        }
      ],
      "sourceType": 7,
      "status": 1
    }
  ],
  "dataChecksPerformed": true,
  "dateCompleted": null,
  "dateCreated": "2018-02-23T12:54:31.611",
  "email": "alan.harper@email.com",
  "forename": "Alan",
  "hasLivenessPerformed": false,
  "hasSelfie": false,
  "id": "abcdef12-abcd-abcd-beef-ab123cd12345",
  "idDocuments": [
    {
      "addressCity": null,
      "addressFull": null,
      "addressPostcode": null,
      "country": "United Kingdom",
      "countryCode": "GBR",
      "dateCreated": "2018-02-23T17:22:11.044",
      "dateOfBirth": "1968-11-23T00:00:00",
      "description": "Passport",
      "documentAnalysisResult": 1,
      "documentNumber": "123456789",
      "documentSide": 1,
      "expiryDate": "2025-04-21T00:00:00",
      "facialMatch": true,
      "forename": "Alan",
      "fullName": "Alan Harper",
      "id": "fedcba89-dead-1278-bead-8901234abcde",
      "isUnderReview": false,
      "manuallyVerified": false,
      "middleName": "William",
      "mrz1": "P

                                            

                                        

                                    

                                

                            

                        

                        
                            
                                
                                    
                                        
                                            GET
                                            Finds registrations by the ReferenceId.
                                        
                                    

                                    {{baseUrl}}/api/registrations/referenceid/:referenceId/summary


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            referenceId
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations/referenceid/:referenceId/summary");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/registrations/referenceid/:referenceId/summary" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations/referenceid/:referenceId/summary"
headers = HTTP::Headers{
  "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/registrations/referenceid/:referenceId/summary"),
    Headers =
    {
        { "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/registrations/referenceid/:referenceId/summary");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations/referenceid/:referenceId/summary"

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

	req.Header.Add("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/registrations/referenceid/:referenceId/summary HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/registrations/referenceid/:referenceId/summary")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations/referenceid/:referenceId/summary"))
    .header("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/registrations/referenceid/:referenceId/summary")
  .get()
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.get("{{baseUrl}}/api/registrations/referenceid/:referenceId/summary")
  .header("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/registrations/referenceid/:referenceId/summary');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/registrations/referenceid/:referenceId/summary',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations/referenceid/:referenceId/summary';
const options = {method: 'GET', headers: {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/registrations/referenceid/:referenceId/summary',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations/referenceid/:referenceId/summary")
  .get()
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations/referenceid/:referenceId/summary',
  headers: {
    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/registrations/referenceid/:referenceId/summary',
  headers: {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/registrations/referenceid/:referenceId/summary');

req.headers({
  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/registrations/referenceid/:referenceId/summary',
  headers: {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/registrations/referenceid/:referenceId/summary';
const options = {method: 'GET', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations/referenceid/:referenceId/summary"]
                                                       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/registrations/referenceid/:referenceId/summary" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations/referenceid/:referenceId/summary",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/registrations/referenceid/:referenceId/summary', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations/referenceid/:referenceId/summary');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations/referenceid/:referenceId/summary');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations/referenceid/:referenceId/summary' -Method GET -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations/referenceid/:referenceId/summary' -Method GET -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/registrations/referenceid/:referenceId/summary", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations/referenceid/:referenceId/summary"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations/referenceid/:referenceId/summary"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations/referenceid/:referenceId/summary")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.get('/baseUrl/api/registrations/referenceid/:referenceId/summary') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/registrations/referenceid/:referenceId/summary";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/registrations/referenceid/:referenceId/summary \
  --header 'apikey: '
                                            
                                            
                                                http GET {{baseUrl}}/api/registrations/referenceid/:referenceId/summary \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/registrations/referenceid/:referenceId/summary
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations/referenceid/:referenceId/summary")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                [
  {
    "Comments": null,
    "DITFDate": null,
    "DITFStatus": 0,
    "bankAccountChecks": [
      {
        "Address1": null,
        "City": null,
        "Forename": null,
        "MiddleName": null,
        "PostCode": null,
        "Surname": null,
        "accountNumber": "12345678",
        "accountNumberValidation": 2,
        "accountNumberValidationText": "Valid",
        "accountStatus": 2,
        "accountStatusText": "Live",
        "accountValid": true,
        "addressValidation": 2,
        "addressValidationText": "Current address",
        "checkDate": "2019-08-01T12:15:22",
        "checkId": "12345678-1234-5678-abcd-1234567890ab",
        "checkStatus": 1,
        "error": false,
        "hasBeenOverridden": false,
        "nameValidation": 2,
        "nameValidationText": "Valid",
        "referenceId": "RF1234",
        "sortcode": "123456",
        "sortcodeValidation": 2,
        "sortcodeValidationText": "Valid"
      }
    ],
    "createdByAgencyUserId": null,
    "creditStatusCheck": {
      "address": null,
      "ccj": [
        {
          "address1": "Flat 30",
          "address2": "Richmond Court, St. Peters Street",
          "address3": null,
          "address4": null,
          "address5": null,
          "amount": "£5000.00",
          "caseNumber": "CS1113-56-33",
          "courtName": "CARMARTHEN COUNTY COURT",
          "dateEnd": "2017-11-09T00:00:00",
          "dob": "1988-12-04T00:00:00",
          "judgementDate": "2017-11-09T00:00:00",
          "judgementType": 2,
          "judgementTypeText": "Satisfaction",
          "name": "ANGELA ZOE SPECIMEN",
          "postcode": "CF24 3AZ"
        }
      ],
      "checkDate": "2019-08-01T12:33:11",
      "companyDirector": [
        {
          "companyAppointments": [
            {
              "address": "FLAT 30, RICHMOND COURT, ST. PETERS STREET, CARDIFF, CF24 3AZ",
              "appointmentDate": "2015-06-11T00:00:00",
              "appointmentType": "Current Director",
              "dob": "1988-12-04T00:00:00",
              "name": "Angela Zoe Specimen",
              "nationality": "British",
              "occupation": "Field Agent",
              "title": "Ms"
            }
          ],
          "companyName": "ANGELS LIMITED",
          "companyRegNo": "00123456",
          "dateAppointed": "2015-06-11T00:00:00",
          "matchType": 3,
          "matchTypeText": "Name, Address and Date of Birth",
          "registeredOffice": "FLAT 3, RICHMOND COURT, ST. PETERS STREET, CARDIFF, CF24 3AZ"
        }
      ],
      "hasBeenOverridden": false,
      "insolvency": [
        {
          "address": {
            "address1": "Flat 30",
            "address2": "Richmond Court",
            "address3": "St Peters Street",
            "address4": null,
            "address5": null,
            "dps": "DPS1",
            "isEmpty": false,
            "postcode": "CF24 3AZ"
          },
          "aliases": "ANGEL UK",
          "assetTotal": "£2000.00",
          "caseNo": "IC123456789-22232",
          "caseType": "Standard",
          "court": "CARMARTHEN COUNTY COURT",
          "debtTotal": "£20000.00",
          "description": "ANGELA ZOE SPECIMEN TRADING AS ANGELS LIMITED",
          "dob": "1988-12-04T00:00:00",
          "name": "ANGELA SPECIMEN",
          "occupation": "Field Agent",
          "presentationDate": "2018-01-15T00:00:00",
          "previousAddress": null,
          "serviceOffice": "MR JON WILLIAM JONES",
          "startDate": "2017-12-01T00:00:00",
          "status": "CURRENT",
          "telephoneNumber": "02920113244",
          "tradingNames": "ANGELS LTD",
          "type": 4,
          "typeText": "England and Wales DRO"
        }
      ],
      "person": null,
      "status": 3
    },
    "customTermsAccepted": false,
    "customTermsAcceptedDateTime": null,
    "customTermsAcceptedVersion": null,
    "dataCheckResult": 1,
    "dataCheckSources": [
      {
        "address": null,
        "dateCreated": "2018-02-23T12:54:32.017",
        "hasBeenOverridden": false,
        "hasPepSanctionsData": false,
        "label": "Mortality",
        "pepSanctionsData": null,
        "person": null,
        "remarks": [
          {
            "category": 1,
            "description": "Halo source indicates this person is not deceased at address 1"
          },
          {
            "category": 4,
            "description": "No middle initial specified by user"
          }
        ],
        "sourceType": 3,
        "status": 1
      },
      {
        "address": null,
        "dateCreated": "2018-02-23T12:54:32.017",
        "hasBeenOverridden": false,
        "hasPepSanctionsData": false,
        "label": "Address and DOB",
        "pepSanctionsData": null,
        "person": null,
        "remarks": [
          {
            "category": 1,
            "description": "(Electoral Register) Address #1 details are valid"
          },
          {
            "category": 2,
            "description": "(Electoral Register) Surname details not matched address #1"
          }
        ],
        "sourceType": 4,
        "status": 2
      },
      {
        "address": null,
        "dateCreated": "2018-02-23T12:54:32.017",
        "hasBeenOverridden": false,
        "hasPepSanctionsData": true,
        "label": "International Sanctions",
        "pepSanctionsData": [
          {
            "addresses": [
              {
                "lines": [
                  "44 Lowbridge Street",
                  "Pasadena",
                  "California",
                  "USA"
                ]
              }
            ],
            "aliases": null,
            "fullName": "Alan Stuart Harper",
            "id": null,
            "positions": [
              {
                "country": "USA",
                "position": "Head of local gov"
              }
            ],
            "sanctionBodies": null,
            "sanctionDates": [
              {
                "date": "1937-04-03T12:00:00Z",
                "day": 3,
                "month": 4,
                "type": 1,
                "year": 1937
              }
            ]
          }
        ],
        "person": null,
        "remarks": [
          {
            "category": 1,
            "description": "Full name has not been matched."
          }
        ],
        "sourceType": 7,
        "status": 1
      }
    ],
    "dataChecksPerformed": true,
    "dateCompleted": null,
    "dateCreated": "2018-02-23T12:54:31.611",
    "email": "alan.harper@email.com",
    "forename": "Alan",
    "hasLivenessPerformed": false,
    "hasSelfie": false,
    "id": "abcdef12-abcd-abcd-beef-ab123cd12345",
    "idDocuments": [
      {
        "addressCity": null,
        "addressFull": null,
        "addressPostcode": null,
        "country": "United Kingdom",
        "countryCode": "GBR",
        "dateCreated": "2018-02-23T17:22:11.044",
        "dateOfBirth": "1968-11-23T00:00:00",
        "description": "Passport",
        "documentAnalysisResult": 1,
        "documentNumber": "123456789",
        "documentSide": 1,
        "expiryDate": "2025-04-21T00:00:00",
        "facialMatch": true,
        "forename": "Alan",
        "fullName": "Alan Harper",
        "id": "fedcba89-dead-1278-bead-8901234abcde",
        "isUnderReview": false,
        "manuallyVerified": false,
        "middleName": "William",
        "mrz1": "P

                                            

                                        

                                    

                                

                            

                        

                        
                            
                                
                                    
                                        
                                            GET
                                            Get a list of supported id document for the specified registration id.
                                        
                                    

                                    {{baseUrl}}/api/registrations/:id/supported-id-documents


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            id
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations/:id/supported-id-documents");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/registrations/:id/supported-id-documents" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations/:id/supported-id-documents"
headers = HTTP::Headers{
  "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/registrations/:id/supported-id-documents"),
    Headers =
    {
        { "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/registrations/:id/supported-id-documents");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations/:id/supported-id-documents"

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

	req.Header.Add("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/registrations/:id/supported-id-documents HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/registrations/:id/supported-id-documents")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations/:id/supported-id-documents"))
    .header("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/registrations/:id/supported-id-documents")
  .get()
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.get("{{baseUrl}}/api/registrations/:id/supported-id-documents")
  .header("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/registrations/:id/supported-id-documents');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/registrations/:id/supported-id-documents',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations/:id/supported-id-documents';
const options = {method: 'GET', headers: {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/registrations/:id/supported-id-documents',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations/:id/supported-id-documents")
  .get()
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations/:id/supported-id-documents',
  headers: {
    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/registrations/:id/supported-id-documents',
  headers: {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/registrations/:id/supported-id-documents');

req.headers({
  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/registrations/:id/supported-id-documents',
  headers: {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/registrations/:id/supported-id-documents';
const options = {method: 'GET', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations/:id/supported-id-documents"]
                                                       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/registrations/:id/supported-id-documents" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations/:id/supported-id-documents",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/registrations/:id/supported-id-documents', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations/:id/supported-id-documents');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations/:id/supported-id-documents');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations/:id/supported-id-documents' -Method GET -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations/:id/supported-id-documents' -Method GET -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/registrations/:id/supported-id-documents", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations/:id/supported-id-documents"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations/:id/supported-id-documents"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations/:id/supported-id-documents")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.get('/baseUrl/api/registrations/:id/supported-id-documents') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/registrations/:id/supported-id-documents";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/registrations/:id/supported-id-documents \
  --header 'apikey: '
                                            
                                            
                                                http GET {{baseUrl}}/api/registrations/:id/supported-id-documents \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/registrations/:id/supported-id-documents
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations/:id/supported-id-documents")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                [
  {
    "name": "Passport",
    "type": 1
  },
  {
    "name": "Driving Licence",
    "type": 2
  },
  {
    "name": "National ID Card",
    "type": 3
  },
  {
    "name": "CSCS Card",
    "type": 4
  },
  {
    "name": "Residence Permit",
    "type": 5
  },
  {
    "name": "Visa",
    "type": 6
  }
]
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            GET
                                            Gets paged registration list by search criteria or nothing if there are no matching fields. Optional parameters may be appended to the query string. Maximum page size is 50.
                                        
                                    

                                    {{baseUrl}}/api/registrations/search


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    


                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations/search");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/registrations/search" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations/search"
headers = HTTP::Headers{
  "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/registrations/search"),
    Headers =
    {
        { "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/registrations/search");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations/search"

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

	req.Header.Add("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/registrations/search HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/registrations/search")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations/search"))
    .header("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/registrations/search")
  .get()
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.get("{{baseUrl}}/api/registrations/search")
  .header("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/registrations/search');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/registrations/search',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations/search';
const options = {method: 'GET', headers: {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/registrations/search',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations/search")
  .get()
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations/search',
  headers: {
    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/registrations/search',
  headers: {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/registrations/search');

req.headers({
  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/registrations/search',
  headers: {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/registrations/search';
const options = {method: 'GET', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations/search"]
                                                       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/registrations/search" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations/search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/registrations/search', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations/search');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations/search');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations/search' -Method GET -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations/search' -Method GET -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/registrations/search", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations/search"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations/search"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations/search")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.get('/baseUrl/api/registrations/search') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/registrations/search \
  --header 'apikey: '
                                            
                                            
                                                http GET {{baseUrl}}/api/registrations/search \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/registrations/search
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations/search")! 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
                                            Gets registration settings or nothing if there are no settings associated with the registration.
                                        
                                    

                                    {{baseUrl}}/api/registrations/:id/settings


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            id
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations/:id/settings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/registrations/:id/settings" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations/:id/settings"
headers = HTTP::Headers{
  "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/registrations/:id/settings"),
    Headers =
    {
        { "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/registrations/:id/settings");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations/:id/settings"

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

	req.Header.Add("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/registrations/:id/settings HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/registrations/:id/settings")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations/:id/settings"))
    .header("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/registrations/:id/settings")
  .get()
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.get("{{baseUrl}}/api/registrations/:id/settings")
  .header("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/registrations/:id/settings');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/registrations/:id/settings',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations/:id/settings';
const options = {method: 'GET', headers: {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/registrations/:id/settings',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations/:id/settings")
  .get()
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations/:id/settings',
  headers: {
    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/registrations/:id/settings',
  headers: {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/registrations/:id/settings');

req.headers({
  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/registrations/:id/settings',
  headers: {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/registrations/:id/settings';
const options = {method: 'GET', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations/:id/settings"]
                                                       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/registrations/:id/settings" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations/:id/settings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/registrations/:id/settings', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations/:id/settings');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations/:id/settings');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations/:id/settings' -Method GET -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations/:id/settings' -Method GET -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/registrations/:id/settings", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations/:id/settings"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations/:id/settings"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations/:id/settings")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.get('/baseUrl/api/registrations/:id/settings') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/registrations/:id/settings";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/registrations/:id/settings \
  --header 'apikey: '
                                            
                                            
                                                http GET {{baseUrl}}/api/registrations/:id/settings \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/registrations/:id/settings
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations/:id/settings")! 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
                                            Resends any invitation for the specified registration.
                                        
                                    

                                    {{baseUrl}}/api/registrations/:id/resend-invitation


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            id
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations/:id/resend-invitation");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/registrations/:id/resend-invitation" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations/:id/resend-invitation"
headers = HTTP::Headers{
  "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/registrations/:id/resend-invitation"),
    Headers =
    {
        { "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/registrations/:id/resend-invitation");
var request = new RestRequest("", Method.Post);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations/:id/resend-invitation"

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

	req.Header.Add("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/registrations/:id/resend-invitation HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/registrations/:id/resend-invitation")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations/:id/resend-invitation"))
    .header("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/registrations/:id/resend-invitation")
  .post(null)
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.post("{{baseUrl}}/api/registrations/:id/resend-invitation")
  .header("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/registrations/:id/resend-invitation');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/registrations/:id/resend-invitation',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations/:id/resend-invitation';
const options = {method: 'POST', headers: {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/registrations/:id/resend-invitation',
  method: 'POST',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations/:id/resend-invitation")
  .post(null)
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations/:id/resend-invitation',
  headers: {
    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/registrations/:id/resend-invitation',
  headers: {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/registrations/:id/resend-invitation');

req.headers({
  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/registrations/:id/resend-invitation',
  headers: {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/registrations/:id/resend-invitation';
const options = {method: 'POST', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations/:id/resend-invitation"]
                                                       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/registrations/:id/resend-invitation" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations/:id/resend-invitation",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "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/registrations/:id/resend-invitation', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations/:id/resend-invitation');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations/:id/resend-invitation');
$request->setRequestMethod('POST');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations/:id/resend-invitation' -Method POST -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations/:id/resend-invitation' -Method POST -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("POST", "/baseUrl/api/registrations/:id/resend-invitation", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations/:id/resend-invitation"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations/:id/resend-invitation"

response <- VERB("POST", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations/:id/resend-invitation")

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

request = Net::HTTP::Post.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.post('/baseUrl/api/registrations/:id/resend-invitation') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/registrations/:id/resend-invitation";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/registrations/:id/resend-invitation \
  --header 'apikey: '
                                            
                                            
                                                http POST {{baseUrl}}/api/registrations/:id/resend-invitation \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method POST \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/registrations/:id/resend-invitation
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations/:id/resend-invitation")! 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 PDF export for a given registration.
                                        
                                    

                                    {{baseUrl}}/api/registrations/:id/pdf-export


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            id
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations/:id/pdf-export");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/registrations/:id/pdf-export" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations/:id/pdf-export"
headers = HTTP::Headers{
  "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/registrations/:id/pdf-export"),
    Headers =
    {
        { "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/registrations/:id/pdf-export");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations/:id/pdf-export"

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

	req.Header.Add("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/registrations/:id/pdf-export HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/registrations/:id/pdf-export")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations/:id/pdf-export"))
    .header("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/registrations/:id/pdf-export")
  .get()
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.get("{{baseUrl}}/api/registrations/:id/pdf-export")
  .header("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/registrations/:id/pdf-export');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/registrations/:id/pdf-export',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations/:id/pdf-export';
const options = {method: 'GET', headers: {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/registrations/:id/pdf-export',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations/:id/pdf-export")
  .get()
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations/:id/pdf-export',
  headers: {
    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/registrations/:id/pdf-export',
  headers: {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/registrations/:id/pdf-export');

req.headers({
  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/registrations/:id/pdf-export',
  headers: {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/registrations/:id/pdf-export';
const options = {method: 'GET', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations/:id/pdf-export"]
                                                       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/registrations/:id/pdf-export" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations/:id/pdf-export",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/registrations/:id/pdf-export', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations/:id/pdf-export');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations/:id/pdf-export');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations/:id/pdf-export' -Method GET -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations/:id/pdf-export' -Method GET -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/registrations/:id/pdf-export", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations/:id/pdf-export"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations/:id/pdf-export"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations/:id/pdf-export")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.get('/baseUrl/api/registrations/:id/pdf-export') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/registrations/:id/pdf-export";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/registrations/:id/pdf-export \
  --header 'apikey: '
                                            
                                            
                                                http GET {{baseUrl}}/api/registrations/:id/pdf-export \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/registrations/:id/pdf-export
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations/:id/pdf-export")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                ZGVmZ2hp
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            GET
                                            Returns a PDF report for a given registration containing specified sections
                                        
                                    

                                    {{baseUrl}}/api/registrations/:id/pdf-export-sections


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            id
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations/:id/pdf-export-sections");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/registrations/:id/pdf-export-sections" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations/:id/pdf-export-sections"
headers = HTTP::Headers{
  "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/registrations/:id/pdf-export-sections"),
    Headers =
    {
        { "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/registrations/:id/pdf-export-sections");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations/:id/pdf-export-sections"

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

	req.Header.Add("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/registrations/:id/pdf-export-sections HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/registrations/:id/pdf-export-sections")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations/:id/pdf-export-sections"))
    .header("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/registrations/:id/pdf-export-sections")
  .get()
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.get("{{baseUrl}}/api/registrations/:id/pdf-export-sections")
  .header("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/registrations/:id/pdf-export-sections');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/registrations/:id/pdf-export-sections',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations/:id/pdf-export-sections';
const options = {method: 'GET', headers: {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/registrations/:id/pdf-export-sections',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations/:id/pdf-export-sections")
  .get()
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations/:id/pdf-export-sections',
  headers: {
    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/registrations/:id/pdf-export-sections',
  headers: {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/registrations/:id/pdf-export-sections');

req.headers({
  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/registrations/:id/pdf-export-sections',
  headers: {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/registrations/:id/pdf-export-sections';
const options = {method: 'GET', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations/:id/pdf-export-sections"]
                                                       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/registrations/:id/pdf-export-sections" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations/:id/pdf-export-sections",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/registrations/:id/pdf-export-sections', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations/:id/pdf-export-sections');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations/:id/pdf-export-sections');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations/:id/pdf-export-sections' -Method GET -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations/:id/pdf-export-sections' -Method GET -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/registrations/:id/pdf-export-sections", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations/:id/pdf-export-sections"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations/:id/pdf-export-sections"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations/:id/pdf-export-sections")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.get('/baseUrl/api/registrations/:id/pdf-export-sections') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/registrations/:id/pdf-export-sections";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/registrations/:id/pdf-export-sections \
  --header 'apikey: '
                                            
                                            
                                                http GET {{baseUrl}}/api/registrations/:id/pdf-export-sections \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/registrations/:id/pdf-export-sections
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations/:id/pdf-export-sections")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                ZGVmZ2hp
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            GET
                                            Returns settlement status PDF (Share Code) for a given registration.
                                        
                                    

                                    {{baseUrl}}/api/registrations/:id/pdf-settlement-status


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            id
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations/:id/pdf-settlement-status");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/registrations/:id/pdf-settlement-status" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations/:id/pdf-settlement-status"
headers = HTTP::Headers{
  "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/registrations/:id/pdf-settlement-status"),
    Headers =
    {
        { "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/registrations/:id/pdf-settlement-status");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations/:id/pdf-settlement-status"

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

	req.Header.Add("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/registrations/:id/pdf-settlement-status HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/registrations/:id/pdf-settlement-status")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations/:id/pdf-settlement-status"))
    .header("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/registrations/:id/pdf-settlement-status")
  .get()
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.get("{{baseUrl}}/api/registrations/:id/pdf-settlement-status")
  .header("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/registrations/:id/pdf-settlement-status');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/registrations/:id/pdf-settlement-status',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations/:id/pdf-settlement-status';
const options = {method: 'GET', headers: {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/registrations/:id/pdf-settlement-status',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations/:id/pdf-settlement-status")
  .get()
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations/:id/pdf-settlement-status',
  headers: {
    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/registrations/:id/pdf-settlement-status',
  headers: {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/registrations/:id/pdf-settlement-status');

req.headers({
  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/registrations/:id/pdf-settlement-status',
  headers: {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/registrations/:id/pdf-settlement-status';
const options = {method: 'GET', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations/:id/pdf-settlement-status"]
                                                       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/registrations/:id/pdf-settlement-status" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations/:id/pdf-settlement-status",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/registrations/:id/pdf-settlement-status', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations/:id/pdf-settlement-status');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations/:id/pdf-settlement-status');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations/:id/pdf-settlement-status' -Method GET -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations/:id/pdf-settlement-status' -Method GET -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/registrations/:id/pdf-settlement-status", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations/:id/pdf-settlement-status"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations/:id/pdf-settlement-status"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations/:id/pdf-settlement-status")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.get('/baseUrl/api/registrations/:id/pdf-settlement-status') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/registrations/:id/pdf-settlement-status";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/registrations/:id/pdf-settlement-status \
  --header 'apikey: '
                                            
                                            
                                                http GET {{baseUrl}}/api/registrations/:id/pdf-settlement-status \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/registrations/:id/pdf-settlement-status
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations/:id/pdf-settlement-status")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                ZGVmZ2hp
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            PUT
                                            Sets an override for a specific check on the registration.
                                        
                                    

                                    {{baseUrl}}/api/registrations/:id/override-check-status


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            id
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations/:id/override-check-status");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
headers = curl_slist_append(headers, "content-type: application/*+json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/registrations/:id/override-check-status" {:headers {:apikey ""
                                                                                                 :content-type "application/*+json"}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations/:id/override-check-status"
headers = HTTP::Headers{
  "apikey" => ""
  "content-type" => "application/*+json"
}

response = HTTP::Client.put url, headers: headers
puts response.body
                                            
                                            
                                                using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/registrations/:id/override-check-status"),
    Headers =
    {
        { "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/registrations/:id/override-check-status");
var request = new RestRequest("", Method.Put);
request.AddHeader("apikey", "");
request.AddHeader("content-type", "application/*+json");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations/:id/override-check-status"

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

	req.Header.Add("apikey", "")
	req.Header.Add("content-type", "application/*+json")

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

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

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

}
                                            
                                            
                                                PUT /baseUrl/api/registrations/:id/override-check-status HTTP/1.1
Apikey: 
Content-Type: application/*+json
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/registrations/:id/override-check-status")
  .setHeader("apikey", "")
  .setHeader("content-type", "application/*+json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations/:id/override-check-status"))
    .header("apikey", "")
    .header("content-type", "application/*+json")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
                                            
                                            
                                                OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/registrations/:id/override-check-status")
  .put(null)
  .addHeader("apikey", "")
  .addHeader("content-type", "application/*+json")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.put("{{baseUrl}}/api/registrations/:id/override-check-status")
  .header("apikey", "")
  .header("content-type", "application/*+json")
  .asString();
                                            
                                            
                                                const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/api/registrations/:id/override-check-status');
xhr.setRequestHeader('apikey', '');
xhr.setRequestHeader('content-type', 'application/*+json');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/registrations/:id/override-check-status',
  headers: {apikey: '', 'content-type': 'application/*+json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations/:id/override-check-status';
const options = {method: 'PUT', headers: {apikey: '', 'content-type': 'application/*+json'}};

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/registrations/:id/override-check-status',
  method: 'PUT',
  headers: {
    apikey: '',
    'content-type': 'application/*+json'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations/:id/override-check-status")
  .put(null)
  .addHeader("apikey", "")
  .addHeader("content-type", "application/*+json")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations/:id/override-check-status',
  headers: {
    apikey: '',
    'content-type': 'application/*+json'
  }
};

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

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

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

req.end();
                                            
                                            
                                                const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/registrations/:id/override-check-status',
  headers: {apikey: '', 'content-type': 'application/*+json'}
};

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

  console.log(body);
});
                                            
                                            
                                                const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/registrations/:id/override-check-status');

req.headers({
  apikey: '',
  'content-type': 'application/*+json'
});

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

  console.log(res.body);
});
                                            
                                            
                                                const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/registrations/:id/override-check-status',
  headers: {apikey: '', 'content-type': 'application/*+json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/registrations/:id/override-check-status';
const options = {method: 'PUT', headers: {apikey: '', 'content-type': 'application/*+json'}};

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

NSDictionary *headers = @{ @"apikey": @"",
                           @"content-type": @"application/*+json" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations/:id/override-check-status"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

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

let uri = Uri.of_string "{{baseUrl}}/api/registrations/:id/override-check-status" in
let headers = Header.add_list (Header.init ()) [
  ("apikey", "");
  ("content-type", "application/*+json");
] in

Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations/:id/override-check-status",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "apikey: ",
    "content-type: application/*+json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
                                            
                                            
                                                request('PUT', '{{baseUrl}}/api/registrations/:id/override-check-status', [
  'headers' => [
    'apikey' => '',
    'content-type' => 'application/*+json',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations/:id/override-check-status');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'apikey' => '',
  'content-type' => 'application/*+json'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations/:id/override-check-status');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'apikey' => '',
  'content-type' => 'application/*+json'
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$headers.Add("content-type", "application/*+json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations/:id/override-check-status' -Method PUT -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$headers.Add("content-type", "application/*+json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations/:id/override-check-status' -Method PUT -Headers $headers
                                            
                                            
                                                import http.client

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

headers = {
    'apikey': "",
    'content-type': "application/*+json"
}

conn.request("PUT", "/baseUrl/api/registrations/:id/override-check-status", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations/:id/override-check-status"

headers = {
    "apikey": "",
    "content-type": "application/*+json"
}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations/:id/override-check-status"

response <- VERB("PUT", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations/:id/override-check-status")

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

request = Net::HTTP::Put.new(url)
request["apikey"] = ''
request["content-type"] = 'application/*+json'

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/*+json'}
)

response = conn.put('/baseUrl/api/registrations/:id/override-check-status') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/registrations/:id/override-check-status";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("apikey", "".parse().unwrap());
    headers.insert("content-type", "application/*+json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

                                            
                                            
                                                curl --request PUT \
  --url {{baseUrl}}/api/registrations/:id/override-check-status \
  --header 'apikey: ' \
  --header 'content-type: application/*+json'
                                            
                                            
                                                http PUT {{baseUrl}}/api/registrations/:id/override-check-status \
  apikey:'' \
  content-type:'application/*+json'
                                            
                                            
                                                wget --quiet \
  --method PUT \
  --header 'apikey: ' \
  --header 'content-type: application/*+json' \
  --output-document \
  - {{baseUrl}}/api/registrations/:id/override-check-status
                                            
                                            
                                                import Foundation

let headers = [
  "apikey": "",
  "content-type": "application/*+json"
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations/:id/override-check-status")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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

dataTask.resume()
                                            
                                        
                                    

                                    
                                    
                                    

                                    
                                    
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            PUT
                                            Updates a registration's contact details.
                                        
                                    

                                    {{baseUrl}}/api/registrations/:id/contact-details


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            id
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations/:id/contact-details");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
headers = curl_slist_append(headers, "content-type: application/*+json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/registrations/:id/contact-details" {:headers {:apikey ""
                                                                                           :content-type "application/*+json"}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations/:id/contact-details"
headers = HTTP::Headers{
  "apikey" => ""
  "content-type" => "application/*+json"
}

response = HTTP::Client.put url, headers: headers
puts response.body
                                            
                                            
                                                using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/registrations/:id/contact-details"),
    Headers =
    {
        { "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/registrations/:id/contact-details");
var request = new RestRequest("", Method.Put);
request.AddHeader("apikey", "");
request.AddHeader("content-type", "application/*+json");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations/:id/contact-details"

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

	req.Header.Add("apikey", "")
	req.Header.Add("content-type", "application/*+json")

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

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

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

}
                                            
                                            
                                                PUT /baseUrl/api/registrations/:id/contact-details HTTP/1.1
Apikey: 
Content-Type: application/*+json
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/registrations/:id/contact-details")
  .setHeader("apikey", "")
  .setHeader("content-type", "application/*+json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations/:id/contact-details"))
    .header("apikey", "")
    .header("content-type", "application/*+json")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
                                            
                                            
                                                OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/registrations/:id/contact-details")
  .put(null)
  .addHeader("apikey", "")
  .addHeader("content-type", "application/*+json")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.put("{{baseUrl}}/api/registrations/:id/contact-details")
  .header("apikey", "")
  .header("content-type", "application/*+json")
  .asString();
                                            
                                            
                                                const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/api/registrations/:id/contact-details');
xhr.setRequestHeader('apikey', '');
xhr.setRequestHeader('content-type', 'application/*+json');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/registrations/:id/contact-details',
  headers: {apikey: '', 'content-type': 'application/*+json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations/:id/contact-details';
const options = {method: 'PUT', headers: {apikey: '', 'content-type': 'application/*+json'}};

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/registrations/:id/contact-details',
  method: 'PUT',
  headers: {
    apikey: '',
    'content-type': 'application/*+json'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations/:id/contact-details")
  .put(null)
  .addHeader("apikey", "")
  .addHeader("content-type", "application/*+json")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations/:id/contact-details',
  headers: {
    apikey: '',
    'content-type': 'application/*+json'
  }
};

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

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

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

req.end();
                                            
                                            
                                                const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/registrations/:id/contact-details',
  headers: {apikey: '', 'content-type': 'application/*+json'}
};

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

  console.log(body);
});
                                            
                                            
                                                const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/registrations/:id/contact-details');

req.headers({
  apikey: '',
  'content-type': 'application/*+json'
});

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

  console.log(res.body);
});
                                            
                                            
                                                const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/registrations/:id/contact-details',
  headers: {apikey: '', 'content-type': 'application/*+json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/registrations/:id/contact-details';
const options = {method: 'PUT', headers: {apikey: '', 'content-type': 'application/*+json'}};

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

NSDictionary *headers = @{ @"apikey": @"",
                           @"content-type": @"application/*+json" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations/:id/contact-details"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

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

let uri = Uri.of_string "{{baseUrl}}/api/registrations/:id/contact-details" in
let headers = Header.add_list (Header.init ()) [
  ("apikey", "");
  ("content-type", "application/*+json");
] in

Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations/:id/contact-details",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "apikey: ",
    "content-type: application/*+json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
                                            
                                            
                                                request('PUT', '{{baseUrl}}/api/registrations/:id/contact-details', [
  'headers' => [
    'apikey' => '',
    'content-type' => 'application/*+json',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations/:id/contact-details');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'apikey' => '',
  'content-type' => 'application/*+json'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations/:id/contact-details');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'apikey' => '',
  'content-type' => 'application/*+json'
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$headers.Add("content-type", "application/*+json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations/:id/contact-details' -Method PUT -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$headers.Add("content-type", "application/*+json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations/:id/contact-details' -Method PUT -Headers $headers
                                            
                                            
                                                import http.client

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

headers = {
    'apikey': "",
    'content-type': "application/*+json"
}

conn.request("PUT", "/baseUrl/api/registrations/:id/contact-details", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations/:id/contact-details"

headers = {
    "apikey": "",
    "content-type": "application/*+json"
}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations/:id/contact-details"

response <- VERB("PUT", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations/:id/contact-details")

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

request = Net::HTTP::Put.new(url)
request["apikey"] = ''
request["content-type"] = 'application/*+json'

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/*+json'}
)

response = conn.put('/baseUrl/api/registrations/:id/contact-details') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/registrations/:id/contact-details";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("apikey", "".parse().unwrap());
    headers.insert("content-type", "application/*+json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

                                            
                                            
                                                curl --request PUT \
  --url {{baseUrl}}/api/registrations/:id/contact-details \
  --header 'apikey: ' \
  --header 'content-type: application/*+json'
                                            
                                            
                                                http PUT {{baseUrl}}/api/registrations/:id/contact-details \
  apikey:'' \
  content-type:'application/*+json'
                                            
                                            
                                                wget --quiet \
  --method PUT \
  --header 'apikey: ' \
  --header 'content-type: application/*+json' \
  --output-document \
  - {{baseUrl}}/api/registrations/:id/contact-details
                                            
                                            
                                                import Foundation

let headers = [
  "apikey": "",
  "content-type": "application/*+json"
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations/:id/contact-details")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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

dataTask.resume()
                                            
                                        
                                    

                                    
                                    
                                    

                                    
                                    
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            PUT
                                            Updates registration settings.
                                        
                                    

                                    {{baseUrl}}/api/registrations/:id/settings


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            id
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations/:id/settings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/registrations/:id/settings" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations/:id/settings"
headers = HTTP::Headers{
  "apikey" => ""
}

response = HTTP::Client.put url, headers: headers
puts response.body
                                            
                                            
                                                using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/registrations/:id/settings"),
    Headers =
    {
        { "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/registrations/:id/settings");
var request = new RestRequest("", Method.Put);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations/:id/settings"

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

	req.Header.Add("apikey", "")

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

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

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

}
                                            
                                            
                                                PUT /baseUrl/api/registrations/:id/settings HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/registrations/:id/settings")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations/:id/settings"))
    .header("apikey", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
                                            
                                            
                                                OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/registrations/:id/settings")
  .put(null)
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.put("{{baseUrl}}/api/registrations/:id/settings")
  .header("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('PUT', '{{baseUrl}}/api/registrations/:id/settings');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/registrations/:id/settings',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations/:id/settings';
const options = {method: 'PUT', headers: {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/registrations/:id/settings',
  method: 'PUT',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations/:id/settings")
  .put(null)
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations/:id/settings',
  headers: {
    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: 'PUT',
  url: '{{baseUrl}}/api/registrations/:id/settings',
  headers: {apikey: ''}
};

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

  console.log(body);
});
                                            
                                            
                                                const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/registrations/:id/settings');

req.headers({
  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: 'PUT',
  url: '{{baseUrl}}/api/registrations/:id/settings',
  headers: {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/registrations/:id/settings';
const options = {method: 'PUT', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations/:id/settings"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

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

let uri = Uri.of_string "{{baseUrl}}/api/registrations/:id/settings" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations/:id/settings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "apikey: "
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
                                            
                                            
                                                request('PUT', '{{baseUrl}}/api/registrations/:id/settings', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations/:id/settings');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations/:id/settings');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations/:id/settings' -Method PUT -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations/:id/settings' -Method PUT -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("PUT", "/baseUrl/api/registrations/:id/settings", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations/:id/settings"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations/:id/settings"

response <- VERB("PUT", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations/:id/settings")

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

request = Net::HTTP::Put.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.put('/baseUrl/api/registrations/:id/settings') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/registrations/:id/settings";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("apikey", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

                                            
                                            
                                                curl --request PUT \
  --url {{baseUrl}}/api/registrations/:id/settings \
  --header 'apikey: '
                                            
                                            
                                                http PUT {{baseUrl}}/api/registrations/:id/settings \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method PUT \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/registrations/:id/settings
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations/:id/settings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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

dataTask.resume()
                                            
                                        
                                    

                                    
                                    
                                    

                                    
                                    
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            PUT
                                            Updates the status of the registration to one specified in the request.
                                        
                                    

                                    {{baseUrl}}/api/registrations/:id/status


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    

                                    
                                        QUERY PARAMS
                                        
                                        
                                            id
                                            
                                        
                                    

                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/registrations/:id/status");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
headers = curl_slist_append(headers, "content-type: application/*+json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/registrations/:id/status" {:headers {:apikey ""
                                                                                  :content-type "application/*+json"}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/registrations/:id/status"
headers = HTTP::Headers{
  "apikey" => ""
  "content-type" => "application/*+json"
}

response = HTTP::Client.put url, headers: headers
puts response.body
                                            
                                            
                                                using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/registrations/:id/status"),
    Headers =
    {
        { "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/registrations/:id/status");
var request = new RestRequest("", Method.Put);
request.AddHeader("apikey", "");
request.AddHeader("content-type", "application/*+json");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/registrations/:id/status"

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

	req.Header.Add("apikey", "")
	req.Header.Add("content-type", "application/*+json")

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

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

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

}
                                            
                                            
                                                PUT /baseUrl/api/registrations/:id/status HTTP/1.1
Apikey: 
Content-Type: application/*+json
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/registrations/:id/status")
  .setHeader("apikey", "")
  .setHeader("content-type", "application/*+json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/registrations/:id/status"))
    .header("apikey", "")
    .header("content-type", "application/*+json")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
                                            
                                            
                                                OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/registrations/:id/status")
  .put(null)
  .addHeader("apikey", "")
  .addHeader("content-type", "application/*+json")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.put("{{baseUrl}}/api/registrations/:id/status")
  .header("apikey", "")
  .header("content-type", "application/*+json")
  .asString();
                                            
                                            
                                                const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/api/registrations/:id/status');
xhr.setRequestHeader('apikey', '');
xhr.setRequestHeader('content-type', 'application/*+json');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/registrations/:id/status',
  headers: {apikey: '', 'content-type': 'application/*+json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/registrations/:id/status';
const options = {method: 'PUT', headers: {apikey: '', 'content-type': 'application/*+json'}};

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/registrations/:id/status',
  method: 'PUT',
  headers: {
    apikey: '',
    'content-type': 'application/*+json'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/registrations/:id/status")
  .put(null)
  .addHeader("apikey", "")
  .addHeader("content-type", "application/*+json")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/registrations/:id/status',
  headers: {
    apikey: '',
    'content-type': 'application/*+json'
  }
};

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

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

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

req.end();
                                            
                                            
                                                const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/registrations/:id/status',
  headers: {apikey: '', 'content-type': 'application/*+json'}
};

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

  console.log(body);
});
                                            
                                            
                                                const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/registrations/:id/status');

req.headers({
  apikey: '',
  'content-type': 'application/*+json'
});

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

  console.log(res.body);
});
                                            
                                            
                                                const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/registrations/:id/status',
  headers: {apikey: '', 'content-type': 'application/*+json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/registrations/:id/status';
const options = {method: 'PUT', headers: {apikey: '', 'content-type': 'application/*+json'}};

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

NSDictionary *headers = @{ @"apikey": @"",
                           @"content-type": @"application/*+json" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/registrations/:id/status"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

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

let uri = Uri.of_string "{{baseUrl}}/api/registrations/:id/status" in
let headers = Header.add_list (Header.init ()) [
  ("apikey", "");
  ("content-type", "application/*+json");
] in

Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/registrations/:id/status",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "apikey: ",
    "content-type: application/*+json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
                                            
                                            
                                                request('PUT', '{{baseUrl}}/api/registrations/:id/status', [
  'headers' => [
    'apikey' => '',
    'content-type' => 'application/*+json',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/registrations/:id/status');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'apikey' => '',
  'content-type' => 'application/*+json'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/registrations/:id/status');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'apikey' => '',
  'content-type' => 'application/*+json'
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$headers.Add("content-type", "application/*+json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/registrations/:id/status' -Method PUT -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$headers.Add("content-type", "application/*+json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/registrations/:id/status' -Method PUT -Headers $headers
                                            
                                            
                                                import http.client

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

headers = {
    'apikey': "",
    'content-type': "application/*+json"
}

conn.request("PUT", "/baseUrl/api/registrations/:id/status", headers=headers)

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

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

url = "{{baseUrl}}/api/registrations/:id/status"

headers = {
    "apikey": "",
    "content-type": "application/*+json"
}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/registrations/:id/status"

response <- VERB("PUT", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/registrations/:id/status")

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

request = Net::HTTP::Put.new(url)
request["apikey"] = ''
request["content-type"] = 'application/*+json'

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/*+json'}
)

response = conn.put('/baseUrl/api/registrations/:id/status') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/registrations/:id/status";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("apikey", "".parse().unwrap());
    headers.insert("content-type", "application/*+json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

                                            
                                            
                                                curl --request PUT \
  --url {{baseUrl}}/api/registrations/:id/status \
  --header 'apikey: ' \
  --header 'content-type: application/*+json'
                                            
                                            
                                                http PUT {{baseUrl}}/api/registrations/:id/status \
  apikey:'' \
  content-type:'application/*+json'
                                            
                                            
                                                wget --quiet \
  --method PUT \
  --header 'apikey: ' \
  --header 'content-type: application/*+json' \
  --output-document \
  - {{baseUrl}}/api/registrations/:id/status
                                            
                                            
                                                import Foundation

let headers = [
  "apikey": "",
  "content-type": "application/*+json"
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/registrations/:id/status")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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

dataTask.resume()
                                            
                                        
                                    

                                    
                                    
                                    

                                    
                                    
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            GET
                                            Gets all available RegTypes.
                                        
                                    

                                    {{baseUrl}}/api/reg-types


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    


                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/reg-types");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/reg-types" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/reg-types"
headers = HTTP::Headers{
  "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/reg-types"),
    Headers =
    {
        { "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/reg-types");
var request = new RestRequest("", Method.Get);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/reg-types"

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

	req.Header.Add("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/reg-types HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/reg-types")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/reg-types"))
    .header("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/reg-types")
  .get()
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.get("{{baseUrl}}/api/reg-types")
  .header("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/reg-types');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/reg-types',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/reg-types';
const options = {method: 'GET', headers: {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/reg-types',
  method: 'GET',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/reg-types")
  .get()
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/reg-types',
  headers: {
    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/reg-types',
  headers: {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/reg-types');

req.headers({
  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/reg-types',
  headers: {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/reg-types';
const options = {method: 'GET', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/reg-types"]
                                                       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/reg-types" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/reg-types",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "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/reg-types', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/reg-types');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/reg-types');
$request->setRequestMethod('GET');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/reg-types' -Method GET -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/reg-types' -Method GET -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("GET", "/baseUrl/api/reg-types", headers=headers)

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

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

url = "{{baseUrl}}/api/reg-types"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/reg-types"

response <- VERB("GET", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/reg-types")

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

request = Net::HTTP::Get.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.get('/baseUrl/api/reg-types') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/reg-types";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/reg-types \
  --header 'apikey: '
                                            
                                            
                                                http GET {{baseUrl}}/api/reg-types \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method GET \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/reg-types
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/reg-types")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                [
  {
    "id": "12345678-1234-1234-1234-1234567890ab",
    "name": "Standard AML Checks"
  }
]
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            POST
                                            Retrieves secure link to registration details page searching by the Registration Id.
                                        
                                    

                                    {{baseUrl}}/api/report-view/by-registrationid


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    


                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/report-view/by-registrationid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/report-view/by-registrationid" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/report-view/by-registrationid"
headers = HTTP::Headers{
  "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/report-view/by-registrationid"),
    Headers =
    {
        { "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/report-view/by-registrationid");
var request = new RestRequest("", Method.Post);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/report-view/by-registrationid"

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

	req.Header.Add("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/report-view/by-registrationid HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/report-view/by-registrationid")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/report-view/by-registrationid"))
    .header("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/report-view/by-registrationid")
  .post(null)
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.post("{{baseUrl}}/api/report-view/by-registrationid")
  .header("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/report-view/by-registrationid');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/report-view/by-registrationid',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/report-view/by-registrationid';
const options = {method: 'POST', headers: {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/report-view/by-registrationid',
  method: 'POST',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/report-view/by-registrationid")
  .post(null)
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/report-view/by-registrationid',
  headers: {
    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/report-view/by-registrationid',
  headers: {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/report-view/by-registrationid');

req.headers({
  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/report-view/by-registrationid',
  headers: {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/report-view/by-registrationid';
const options = {method: 'POST', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/report-view/by-registrationid"]
                                                       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/report-view/by-registrationid" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/report-view/by-registrationid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "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/report-view/by-registrationid', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/report-view/by-registrationid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/report-view/by-registrationid');
$request->setRequestMethod('POST');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/report-view/by-registrationid' -Method POST -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/report-view/by-registrationid' -Method POST -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("POST", "/baseUrl/api/report-view/by-registrationid", headers=headers)

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

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

url = "{{baseUrl}}/api/report-view/by-registrationid"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/report-view/by-registrationid"

response <- VERB("POST", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/report-view/by-registrationid")

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

request = Net::HTTP::Post.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.post('/baseUrl/api/report-view/by-registrationid') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/report-view/by-registrationid";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/report-view/by-registrationid \
  --header 'apikey: '
                                            
                                            
                                                http POST {{baseUrl}}/api/report-view/by-registrationid \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method POST \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/report-view/by-registrationid
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/report-view/by-registrationid")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                {
  "results": [
    {
      "forename": "Mike",
      "surname": "Jones",
      "url": "https://report.credas.co.uk/link/66ddf7c2-d3b1-4db3-ac13-2ef44d99da74",
      "validUntil": "2023-03-06T07:31:35.8237383Z"
    }
  ]
}
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            POST
                                            Retrieves secure links to registration details pages searching by the Reference Id.
                                        
                                    

                                    {{baseUrl}}/api/report-view/by-referenceid


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    


                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/report-view/by-referenceid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/report-view/by-referenceid" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/report-view/by-referenceid"
headers = HTTP::Headers{
  "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/report-view/by-referenceid"),
    Headers =
    {
        { "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/report-view/by-referenceid");
var request = new RestRequest("", Method.Post);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/report-view/by-referenceid"

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

	req.Header.Add("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/report-view/by-referenceid HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/report-view/by-referenceid")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/report-view/by-referenceid"))
    .header("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/report-view/by-referenceid")
  .post(null)
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.post("{{baseUrl}}/api/report-view/by-referenceid")
  .header("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/report-view/by-referenceid');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/report-view/by-referenceid',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/report-view/by-referenceid';
const options = {method: 'POST', headers: {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/report-view/by-referenceid',
  method: 'POST',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/report-view/by-referenceid")
  .post(null)
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/report-view/by-referenceid',
  headers: {
    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/report-view/by-referenceid',
  headers: {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/report-view/by-referenceid');

req.headers({
  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/report-view/by-referenceid',
  headers: {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/report-view/by-referenceid';
const options = {method: 'POST', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/report-view/by-referenceid"]
                                                       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/report-view/by-referenceid" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/report-view/by-referenceid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "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/report-view/by-referenceid', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/report-view/by-referenceid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/report-view/by-referenceid');
$request->setRequestMethod('POST');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/report-view/by-referenceid' -Method POST -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/report-view/by-referenceid' -Method POST -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("POST", "/baseUrl/api/report-view/by-referenceid", headers=headers)

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

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

url = "{{baseUrl}}/api/report-view/by-referenceid"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/report-view/by-referenceid"

response <- VERB("POST", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/report-view/by-referenceid")

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

request = Net::HTTP::Post.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.post('/baseUrl/api/report-view/by-referenceid') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/report-view/by-referenceid";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/report-view/by-referenceid \
  --header 'apikey: '
                                            
                                            
                                                http POST {{baseUrl}}/api/report-view/by-referenceid \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method POST \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/report-view/by-referenceid
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/report-view/by-referenceid")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                {
  "results": [
    {
      "forename": "Edward",
      "surname": "Roberts",
      "url": "https://report.credas.co.uk/link/f7ec8ac1-d935-413b-9100-c7b9b498ca1d",
      "validUntil": "2023-03-06T07:31:35.8216208Z"
    }
  ]
}
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            POST
                                            Retrieves secure link to web verification page searching by the Registration Id.
                                        
                                    

                                    {{baseUrl}}/api/web-verifications/by-registrationid


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    


                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/web-verifications/by-registrationid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/web-verifications/by-registrationid" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/web-verifications/by-registrationid"
headers = HTTP::Headers{
  "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/web-verifications/by-registrationid"),
    Headers =
    {
        { "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/web-verifications/by-registrationid");
var request = new RestRequest("", Method.Post);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/web-verifications/by-registrationid"

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

	req.Header.Add("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/web-verifications/by-registrationid HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/web-verifications/by-registrationid")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/web-verifications/by-registrationid"))
    .header("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/web-verifications/by-registrationid")
  .post(null)
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.post("{{baseUrl}}/api/web-verifications/by-registrationid")
  .header("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/web-verifications/by-registrationid');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/web-verifications/by-registrationid',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/web-verifications/by-registrationid';
const options = {method: 'POST', headers: {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/web-verifications/by-registrationid',
  method: 'POST',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/web-verifications/by-registrationid")
  .post(null)
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/web-verifications/by-registrationid',
  headers: {
    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/web-verifications/by-registrationid',
  headers: {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/web-verifications/by-registrationid');

req.headers({
  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/web-verifications/by-registrationid',
  headers: {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/web-verifications/by-registrationid';
const options = {method: 'POST', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/web-verifications/by-registrationid"]
                                                       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/web-verifications/by-registrationid" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/web-verifications/by-registrationid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "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/web-verifications/by-registrationid', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/web-verifications/by-registrationid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/web-verifications/by-registrationid');
$request->setRequestMethod('POST');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/web-verifications/by-registrationid' -Method POST -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/web-verifications/by-registrationid' -Method POST -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("POST", "/baseUrl/api/web-verifications/by-registrationid", headers=headers)

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

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

url = "{{baseUrl}}/api/web-verifications/by-registrationid"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/web-verifications/by-registrationid"

response <- VERB("POST", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/web-verifications/by-registrationid")

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

request = Net::HTTP::Post.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.post('/baseUrl/api/web-verifications/by-registrationid') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/web-verifications/by-registrationid";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/web-verifications/by-registrationid \
  --header 'apikey: '
                                            
                                            
                                                http POST {{baseUrl}}/api/web-verifications/by-registrationid \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method POST \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/web-verifications/by-registrationid
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/web-verifications/by-registrationid")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                {
  "results": [
    {
      "journeyUrl": {
        "url": "https://verify.credas.co.uk/link/66ddf7c2-d3b1-4db3-ac13-2ef44d99da74",
        "validUntil": "2023-03-06T07:31:35.8278916Z"
      }
    }
  ]
}
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                        
                                            POST
                                            Retrieves secure links to web verification pages searching by the Reference Id.
                                        
                                    

                                    {{baseUrl}}/api/web-verifications/by-referenceid


                                    
                                        HEADERS
                                        
                                        
                                            apikey
                                            
                                        
                                    


                                
                            

                            
                                
                                    
                                        Examples
                                    

                                    
                                    
                                        REQUEST
                                        
                                        
                                            
                                                CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/web-verifications/by-referenceid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "apikey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
                                            
                                            
                                                (require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/web-verifications/by-referenceid" {:headers {:apikey ""}})
                                            
                                            
                                                require "http/client"

url = "{{baseUrl}}/api/web-verifications/by-referenceid"
headers = HTTP::Headers{
  "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/web-verifications/by-referenceid"),
    Headers =
    {
        { "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/web-verifications/by-referenceid");
var request = new RestRequest("", Method.Post);
request.AddHeader("apikey", "");
var response = client.Execute(request);
                                            
                                            
                                                package main

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

func main() {

	url := "{{baseUrl}}/api/web-verifications/by-referenceid"

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

	req.Header.Add("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/web-verifications/by-referenceid HTTP/1.1
Apikey: 
Host: example.com


                                            
                                            
                                                AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/web-verifications/by-referenceid")
  .setHeader("apikey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
                                            
                                            
                                                HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/web-verifications/by-referenceid"))
    .header("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/web-verifications/by-referenceid")
  .post(null)
  .addHeader("apikey", "")
  .build();

Response response = client.newCall(request).execute();
                                            
                                            
                                                HttpResponse response = Unirest.post("{{baseUrl}}/api/web-verifications/by-referenceid")
  .header("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/web-verifications/by-referenceid');
xhr.setRequestHeader('apikey', '');

xhr.send(data);
                                            
                                            
                                                import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/web-verifications/by-referenceid',
  headers: {apikey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
                                            
                                            
                                                const url = '{{baseUrl}}/api/web-verifications/by-referenceid';
const options = {method: 'POST', headers: {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/web-verifications/by-referenceid',
  method: 'POST',
  headers: {
    apikey: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
                                            
                                            
                                                val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/web-verifications/by-referenceid")
  .post(null)
  .addHeader("apikey", "")
  .build()

val response = client.newCall(request).execute()
                                            
                                            
                                                const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/web-verifications/by-referenceid',
  headers: {
    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/web-verifications/by-referenceid',
  headers: {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/web-verifications/by-referenceid');

req.headers({
  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/web-verifications/by-referenceid',
  headers: {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/web-verifications/by-referenceid';
const options = {method: 'POST', headers: {apikey: ''}};

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

NSDictionary *headers = @{ @"apikey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/web-verifications/by-referenceid"]
                                                       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/web-verifications/by-referenceid" in
let headers = Header.add (Header.init ()) "apikey" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
                                            
                                            
                                                 "{{baseUrl}}/api/web-verifications/by-referenceid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "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/web-verifications/by-referenceid', [
  'headers' => [
    'apikey' => '',
  ],
]);

echo $response->getBody();
                                            
                                            
                                                setUrl('{{baseUrl}}/api/web-verifications/by-referenceid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'apikey' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
                                            
                                            
                                                setRequestUrl('{{baseUrl}}/api/web-verifications/by-referenceid');
$request->setRequestMethod('POST');
$request->setHeaders([
  'apikey' => ''
]);

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

echo $response->getBody();
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/web-verifications/by-referenceid' -Method POST -Headers $headers
                                            
                                            
                                                $headers=@{}
$headers.Add("apikey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/web-verifications/by-referenceid' -Method POST -Headers $headers
                                            
                                            
                                                import http.client

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

headers = { 'apikey': "" }

conn.request("POST", "/baseUrl/api/web-verifications/by-referenceid", headers=headers)

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

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

url = "{{baseUrl}}/api/web-verifications/by-referenceid"

headers = {"apikey": ""}

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

print(response.json())
                                            
                                            
                                                library(httr)

url <- "{{baseUrl}}/api/web-verifications/by-referenceid"

response <- VERB("POST", url, add_headers('apikey' = ''), content_type("application/octet-stream"))

content(response, "text")
                                            
                                            
                                                require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/web-verifications/by-referenceid")

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

request = Net::HTTP::Post.new(url)
request["apikey"] = ''

response = http.request(request)
puts response.read_body
                                            
                                            
                                                require 'faraday'

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

response = conn.post('/baseUrl/api/web-verifications/by-referenceid') do |req|
  req.headers['apikey'] = ''
end

puts response.status
puts response.body
                                            
                                            
                                                use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/web-verifications/by-referenceid";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("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/web-verifications/by-referenceid \
  --header 'apikey: '
                                            
                                            
                                                http POST {{baseUrl}}/api/web-verifications/by-referenceid \
  apikey:''
                                            
                                            
                                                wget --quiet \
  --method POST \
  --header 'apikey: ' \
  --output-document \
  - {{baseUrl}}/api/web-verifications/by-referenceid
                                            
                                            
                                                import Foundation

let headers = ["apikey": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/web-verifications/by-referenceid")! 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()
                                            
                                        
                                    

                                    
                                    
                                        
                                    

                                    
                                    
                                        
                                            
                                                RESPONSE HEADERS
                                                
                                                
                                                    Content-Type
                                                    application/json
                                                
                                            

                                            
                                                RESPONSE BODY json
                                                
                                                {
  "results": [
    {
      "journeyUrl": {
        "url": "https://pi-verify.credas.co.uk/link/f7ec8ac1-d935-413b-9100-c7b9b498ca1d",
        "validUntil": "2023-03-06T07:31:35.8261095Z"
      }
    }
  ]
}