{
  "datacenter": "hq",
  "data_dir": "C:\\consul\\data-hq",
  "log_level": "INFO",
  "server": false,
  "retry_join": [ "server-a", "server-b", "server-c" ],
  "ui": true,
  "http_config": {
    "response_headers": {
      "Access-Control-Allow-Origin": "*"
    }
  }
}

#  example using only command line parameters
docker run -d --name=HITBTC --restart=always --net=host coinapi/oeml-api --OEML:ExchangeId HITBTC \
    --OD:PublicApiKey _public_api_key_ --OD:PrivateApiKey _private_api_key_ \
    --CoinAPI:ApiKey _coinapi_api_key_ 
docker run -d --restart=always --net=host coinapi/oeml-webui
docker run --net=host coinapi/oeml-cli

# example with enviroment variables file
cat > oeml.env << EOF
CoinAPI__ApiKey=_coinapi_api_key_

OD__PublicApiKey=_public_api_key_
OD__PrivateApiKey=_private_api_key_
EOF

docker run -d --name=HITBTC --restart=always --net=host coinapi/oeml-api --env-file oeml.env --OEML:ExchangeId HITBTC
docker run -d --name=BITFINEX --restart=always --net=host coinapi/oeml-api --env-file oeml.env --OEML:ExchangeId BITFINEX
docker run -d --name=OEML_EDGE --restart=always --net=host coinapi/oeml-api --env-file oeml.env

$ helm repo add coinapi-charts https://coinapi.github.io/helm-charts/
$ helm repo update

cat > values.yaml << EOF

# Using WebUI (oeml-api/values.yaml)
webUI:
  enabled: true

# Using composite (oeml-api/values.yaml)
oemlCompositeAPI:
  enabled: true

# Setting the CoinAPI key (oeml-api/values.yaml)
extraEnv:
  - name: CoinAPI__ApiKey
    value: "YOUR_COINAPI_APIKEY"

# Specify listing of the accounts that EMS should manage (oeml-api/acct-dev.yaml)
accounts:
  # Binance spot market 
  - name: "binance"
    env:
      - name: OEML__ExchangeId
        value: "BINANCE"
      - name: OD__PublicApiKey
        value: "XXX"
      - name: OD__PrivateApiKey
        value: "YYY"

  # Binance spot testnet
  - name: "binanceuat"
    env:
      - name: OEML__ExchangeId
        value: "BINANCEUAT"
      - name: OD__PublicApiKey
        value: "XXX"
      - name: OD__PrivateApiKey
        value: "YYY"

EOF

$ helm install oeml-api coinapi-charts/oeml-api -f values.yaml

$ helm install oeml-api coinapi-charts/oeml-api -f values.yaml --set oemlAPI.tag={version}

kubectl get pods | grep oeml

oeml-api-binance-7754fc95cc-x2gkk        1/1     Running
oeml-api-binance-test-757c8bbd95-2mxd5   1/1     Running
oeml-api-composite-d5688f8f6-csbwh       1/1     Running
oeml-webui-685cd94d77-hq68j              1/1     Running 

kubectl logs oeml-api-binance-7754fc95cc-x2gkk

kubectl logs oeml-api-binance-test-757c8bbd95-2mxd5

[02:22:04 WRN] Overriding address(es) 'http://+:80'. Binding
to endpoints defined in UseKestrel() instead.
Hosting environment: Production
Content root path: /app
Now listening on: http://[::]:80
Application started. Press Ctrl+C to shut down.

kubectl get svc | grep oeml

oeml-api-binance        ClusterIP   10.112.9.119    <none>        80/TCP
oeml-api-binance-test   ClusterIP   10.112.15.239   <none>        80/TCP
oeml-api-composite      NodePort    10.112.8.159    <none>        80:30578/TCP
oeml-webui              NodePort    10.112.4.195    <none>        80:30857/TCP              

kubectl apply -f https://k8s.io/examples/application/shell-demo.yaml

kubectl get pod shell-demo

kubectl get svc | grep oeml-api-composite
>oeml-api-composite      NodePort    10.112.8.159  

kubectl exec --stdin --tty shell-demo -- /bin/bash

curl 10.112.8.159/v1/balances --header 'Accept: application/json'

curl oeml-api-composite.default.svc.cluster.local/v1/balances --header 'Accept: application/json'

[
  {
    "type": "BALANCE_SNAPSHOT",
    "exchange_id": "BINANCE",
  },
  {
    "type": "BALANCE_SNAPSHOT",
    "exchange_id": "BINANCEUAT",
    "data": [
      {
        "id": "XRP",
        "asset_id_exchange": "XRP",
        "asset_id_coinapi": null,
        "balance": 50000.00000000,
        "available": 50000.00000000,
        "locked": 0.00000000,
        "traded": 0.0,
        "last_updated_by": "EXCHANGE",
        "rate_usd": null
      },
      // more entries
      ]
  }
]

exit 

kubectl delete pod shell-demo

 kubectl port-forward service/oeml-api-composite 8080:80

Forwarding from 127.0.0.1:8080 -> 80
Forwarding from [::1]:8080 -> 80

curl localhost:8080/v1/balances --header 'Accept: application/json'

[
  {
    "type": "BALANCE_SNAPSHOT",
    "exchange_id": "BINANCE",
  },
  {
    "type": "BALANCE_SNAPSHOT",
    "exchange_id": "BINANCEUAT",
    "data": [
      {
      // more entries
      },
      ]
  }
]

curl --request GET \
  --url https://ems-mgmt-sandbox.coinapi.io/v1/accounts \
  --header 'Accept: application/json' \
  --header 'X-CoinAPI-Key: API_KEY'

var client = new RestClient("https://ems-mgmt-sandbox.coinapi.io/v1/accounts");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("X-CoinAPI-Key", "API_KEY");
IRestResponse response = client.Execute(request);

package main

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

func main() {

    url := "https://ems-mgmt-sandbox.coinapi.io/v1/accounts"

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

    req.Header.Add("Accept", "application/json")
    req.Header.Add("X-CoinAPI-Key", "API_KEY")

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

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

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

}

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", "https://ems-mgmt-sandbox.coinapi.io/v1/accounts");
xhr.setRequestHeader("Accept", "application/json");
xhr.setRequestHeader("X-CoinAPI-Key", "API_KEY");

xhr.send(data);

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://ems-mgmt-sandbox.coinapi.io/v1/accounts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Accept: application/json",
    "X-CoinAPI-Key: API_KEY"
  ],
]);

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

curl_close($curl);

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

import http.client

conn = http.client.HTTPSConnection("ems-mgmt-sandbox.coinapi.io")

headers = {
    'Accept': "application/json",
    'X-CoinAPI-Key': "API_KEY"
    }

conn.request("GET", "/v1/accounts", headers=headers)

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

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

require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://ems-mgmt-sandbox.coinapi.io/v1/accounts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Get.new(url)
request["Accept"] = 'application/json'
request["X-CoinAPI-Key"] = 'API_KEY'

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

HttpResponse<String> response = Unirest.get("https://ems-mgmt-sandbox.coinapi.io/v1/accounts")
  .header("Accept", "application/json")
  .header("X-CoinAPI-Key", "API_KEY")
  .asString();

[
  {
    "exchange_id": "string",
    "parameters": [
      {
        "key": "PublicApiKey",
        "value": "36279b02-d24f-40be-a61b-e9fd7de46dd6"
      }
    ]
  }
]

curl --request POST \
  --url https://ems-mgmt-sandbox.coinapi.io/v1/accounts \
  --header 'Content-Type: application/json' \
  --header 'X-CoinAPI-Key: API_KEY' \
  --data '{"exchange_id":"string","parameters":[{"key":"PublicApiKey","value":"36279b02-d24f-40be-a61b-e9fd7de46dd6"}]}'

var client = new RestClient("https://ems-mgmt-sandbox.coinapi.io/v1/accounts");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("X-CoinAPI-Key", "API_KEY");
request.AddParameter("application/json", "{\"exchange_id\":\"string\",\"parameters\":[{\"key\":\"PublicApiKey\",\"value\":\"36279b02-d24f-40be-a61b-e9fd7de46dd6\"}]}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

package main

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

func main() {

    url := "https://ems-mgmt-sandbox.coinapi.io/v1/accounts"

    payload := strings.NewReader("{\"exchange_id\":\"string\",\"parameters\":[{\"key\":\"PublicApiKey\",\"value\":\"36279b02-d24f-40be-a61b-e9fd7de46dd6\"}]}")

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

    req.Header.Add("Content-Type", "application/json")
    req.Header.Add("X-CoinAPI-Key", "API_KEY")

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

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

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

}

const data = JSON.stringify({
  "exchange_id": "string",
  "parameters": [
    {
      "key": "PublicApiKey",
      "value": "36279b02-d24f-40be-a61b-e9fd7de46dd6"
    }
  ]
});

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

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

xhr.open("POST", "https://ems-mgmt-sandbox.coinapi.io/v1/accounts");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.setRequestHeader("X-CoinAPI-Key", "API_KEY");

xhr.send(data);

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://ems-mgmt-sandbox.coinapi.io/v1/accounts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "{\"exchange_id\":\"string\",\"parameters\":[{\"key\":\"PublicApiKey\",\"value\":\"36279b02-d24f-40be-a61b-e9fd7de46dd6\"}]}",
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json",
    "X-CoinAPI-Key: API_KEY"
  ],
]);

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

curl_close($curl);

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

import http.client

conn = http.client.HTTPSConnection("ems-mgmt-sandbox.coinapi.io")

payload = "{\"exchange_id\":\"string\",\"parameters\":[{\"key\":\"PublicApiKey\",\"value\":\"36279b02-d24f-40be-a61b-e9fd7de46dd6\"}]}"

headers = {
    'Content-Type': "application/json",
    'X-CoinAPI-Key': "API_KEY"
    }

conn.request("POST", "/v1/accounts", payload, headers)

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

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

require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://ems-mgmt-sandbox.coinapi.io/v1/accounts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request["X-CoinAPI-Key"] = 'API_KEY'
request.body = "{\"exchange_id\":\"string\",\"parameters\":[{\"key\":\"PublicApiKey\",\"value\":\"36279b02-d24f-40be-a61b-e9fd7de46dd6\"}]}"

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

HttpResponse<String> response = Unirest.post("https://ems-mgmt-sandbox.coinapi.io/v1/accounts")
  .header("Content-Type", "application/json")
  .header("X-CoinAPI-Key", "API_KEY")
  .body("{\"exchange_id\":\"string\",\"parameters\":[{\"key\":\"PublicApiKey\",\"value\":\"36279b02-d24f-40be-a61b-e9fd7de46dd6\"}]}")
  .asString();

{
  "exchange_id": "string",
  "parameters": [
    {
      "key": "PublicApiKey",
      "value": "36279b02-d24f-40be-a61b-e9fd7de46dd6"
    }
  ]
}

curl --request DELETE \
  --url 'https://ems-mgmt-sandbox.coinapi.io/v1/accounts?exchange_id=string' \
  --header 'X-CoinAPI-Key: API_KEY'

var client = new RestClient("https://ems-mgmt-sandbox.coinapi.io/v1/accounts?exchange_id=string");
var request = new RestRequest(Method.DELETE);
request.AddHeader("X-CoinAPI-Key", "API_KEY");
IRestResponse response = client.Execute(request);

package main

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

func main() {

    url := "https://ems-mgmt-sandbox.coinapi.io/v1/accounts?exchange_id=string"

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

    req.Header.Add("X-CoinAPI-Key", "API_KEY")

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

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

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

}

const data = null;

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

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

xhr.open("DELETE", "https://ems-mgmt-sandbox.coinapi.io/v1/accounts?exchange_id=string");
xhr.setRequestHeader("X-CoinAPI-Key", "API_KEY");

xhr.send(data);

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://ems-mgmt-sandbox.coinapi.io/v1/accounts?exchange_id=string",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "X-CoinAPI-Key: API_KEY"
  ],
]);

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

curl_close($curl);

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

import http.client

conn = http.client.HTTPSConnection("ems-mgmt-sandbox.coinapi.io")

headers = { 'X-CoinAPI-Key': "API_KEY" }

conn.request("DELETE", "/v1/accounts?exchange_id=string", headers=headers)

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

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

require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://ems-mgmt-sandbox.coinapi.io/v1/accounts?exchange_id=string")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Delete.new(url)
request["X-CoinAPI-Key"] = 'API_KEY'

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

HttpResponse<String> response = Unirest.delete("https://ems-mgmt-sandbox.coinapi.io/v1/accounts?exchange_id=string")
  .header("X-CoinAPI-Key", "API_KEY")
  .asString();

curl --request DELETE \
  --url https://ems-mgmt-sandbox.coinapi.io/v1/accounts/all \
  --header 'X-CoinAPI-Key: API_KEY'

var client = new RestClient("https://ems-mgmt-sandbox.coinapi.io/v1/accounts/all");
var request = new RestRequest(Method.DELETE);
request.AddHeader("X-CoinAPI-Key", "API_KEY");
IRestResponse response = client.Execute(request);

package main

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

func main() {

    url := "https://ems-mgmt-sandbox.coinapi.io/v1/accounts/all"

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

    req.Header.Add("X-CoinAPI-Key", "API_KEY")

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

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

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

}

const data = null;

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

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

xhr.open("DELETE", "https://ems-mgmt-sandbox.coinapi.io/v1/accounts/all");
xhr.setRequestHeader("X-CoinAPI-Key", "API_KEY");

xhr.send(data);

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://ems-mgmt-sandbox.coinapi.io/v1/accounts/all",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "X-CoinAPI-Key: API_KEY"
  ],
]);

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

curl_close($curl);

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

import http.client

conn = http.client.HTTPSConnection("ems-mgmt-sandbox.coinapi.io")

headers = { 'X-CoinAPI-Key': "API_KEY" }

conn.request("DELETE", "/v1/accounts/all", headers=headers)

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

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

require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://ems-mgmt-sandbox.coinapi.io/v1/accounts/all")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Delete.new(url)
request["X-CoinAPI-Key"] = 'API_KEY'

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

HttpResponse<String> response = Unirest.delete("https://ems-mgmt-sandbox.coinapi.io/v1/accounts/all")
  .header("X-CoinAPI-Key", "API_KEY")
  .asString();

curl --request GET \
  --url https://ems-mgmt-sandbox.coinapi.io/v1/exchanges \
  --header 'Accept: application/json' \
  --header 'X-CoinAPI-Key: API_KEY'

var client = new RestClient("https://ems-mgmt-sandbox.coinapi.io/v1/exchanges");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("X-CoinAPI-Key", "API_KEY");
IRestResponse response = client.Execute(request);

package main

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

func main() {

    url := "https://ems-mgmt-sandbox.coinapi.io/v1/exchanges"

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

    req.Header.Add("Accept", "application/json")
    req.Header.Add("X-CoinAPI-Key", "API_KEY")

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

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

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

}

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", "https://ems-mgmt-sandbox.coinapi.io/v1/exchanges");
xhr.setRequestHeader("Accept", "application/json");
xhr.setRequestHeader("X-CoinAPI-Key", "API_KEY");

xhr.send(data);

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://ems-mgmt-sandbox.coinapi.io/v1/exchanges",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Accept: application/json",
    "X-CoinAPI-Key: API_KEY"
  ],
]);

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

curl_close($curl);

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

import http.client

conn = http.client.HTTPSConnection("ems-mgmt-sandbox.coinapi.io")

headers = {
    'Accept': "application/json",
    'X-CoinAPI-Key': "API_KEY"
    }

conn.request("GET", "/v1/exchanges", headers=headers)

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

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

require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://ems-mgmt-sandbox.coinapi.io/v1/exchanges")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Get.new(url)
request["Accept"] = 'application/json'
request["X-CoinAPI-Key"] = 'API_KEY'

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

HttpResponse<String> response = Unirest.get("https://ems-mgmt-sandbox.coinapi.io/v1/exchanges")
  .header("Accept", "application/json")
  .header("X-CoinAPI-Key", "API_KEY")
  .asString();

[
  {
    "exchange_id": "string",
    "location_id": "string",
    "required_parameters": [
      "string"
    ]
  }
]

curl --request GET \
  --url https://ems-mgmt-sandbox.coinapi.io/v1/locations \
  --header 'Accept: application/json' \
  --header 'X-CoinAPI-Key: API_KEY'

var client = new RestClient("https://ems-mgmt-sandbox.coinapi.io/v1/locations");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("X-CoinAPI-Key", "API_KEY");
IRestResponse response = client.Execute(request);

package main

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

func main() {

    url := "https://ems-mgmt-sandbox.coinapi.io/v1/locations"

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

    req.Header.Add("Accept", "application/json")
    req.Header.Add("X-CoinAPI-Key", "API_KEY")

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

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

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

}

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", "https://ems-mgmt-sandbox.coinapi.io/v1/locations");
xhr.setRequestHeader("Accept", "application/json");
xhr.setRequestHeader("X-CoinAPI-Key", "API_KEY");

xhr.send(data);

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://ems-mgmt-sandbox.coinapi.io/v1/locations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Accept: application/json",
    "X-CoinAPI-Key: API_KEY"
  ],
]);

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

curl_close($curl);

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

import http.client

conn = http.client.HTTPSConnection("ems-mgmt-sandbox.coinapi.io")

headers = {
    'Accept': "application/json",
    'X-CoinAPI-Key': "API_KEY"
    }

conn.request("GET", "/v1/locations", headers=headers)

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

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

require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://ems-mgmt-sandbox.coinapi.io/v1/locations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Get.new(url)
request["Accept"] = 'application/json'
request["X-CoinAPI-Key"] = 'API_KEY'

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

HttpResponse<String> response = Unirest.get("https://ems-mgmt-sandbox.coinapi.io/v1/locations")
  .header("Accept", "application/json")
  .header("X-CoinAPI-Key", "API_KEY")
  .asString();

[
  {
    "location_id": "aws-us-east-1",
    "region_name": "us-east-1",
    "provider_name": "aws"
  }
]

curl --request GET \
  --url https://ems-mgmt-sandbox.coinapi.io/v1/endpoints \
  --header 'Accept: application/json' \
  --header 'X-CoinAPI-Key: API_KEY'

var client = new RestClient("https://ems-mgmt-sandbox.coinapi.io/v1/endpoints");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("X-CoinAPI-Key", "API_KEY");
IRestResponse response = client.Execute(request);

package main

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

func main() {

    url := "https://ems-mgmt-sandbox.coinapi.io/v1/endpoints"

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

    req.Header.Add("Accept", "application/json")
    req.Header.Add("X-CoinAPI-Key", "API_KEY")

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

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

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

}

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", "https://ems-mgmt-sandbox.coinapi.io/v1/endpoints");
xhr.setRequestHeader("Accept", "application/json");
xhr.setRequestHeader("X-CoinAPI-Key", "API_KEY");

xhr.send(data);

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://ems-mgmt-sandbox.coinapi.io/v1/endpoints",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Accept: application/json",
    "X-CoinAPI-Key: API_KEY"
  ],
]);

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

curl_close($curl);

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

import http.client

conn = http.client.HTTPSConnection("ems-mgmt-sandbox.coinapi.io")

headers = {
    'Accept': "application/json",
    'X-CoinAPI-Key': "API_KEY"
    }

conn.request("GET", "/v1/endpoints", headers=headers)

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

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

require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://ems-mgmt-sandbox.coinapi.io/v1/endpoints")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Get.new(url)
request["Accept"] = 'application/json'
request["X-CoinAPI-Key"] = 'API_KEY'

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

HttpResponse<String> response = Unirest.get("https://ems-mgmt-sandbox.coinapi.io/v1/endpoints")
  .header("Accept", "application/json")
  .header("X-CoinAPI-Key", "API_KEY")
  .asString();

[
  {
    "exchange_id": "KRAKEN",
    "location_id": "aws-us-east-2",
    "endpoint_schema": "https",
    "endpoint_host": "1314.51253.51.ec2.eu-west-1.amazonaws.com",
    "endpoint_url": "https://1314.51253.51.ec2.eu-west-1.amazonaws.com/"
  }
]

curl --request GET \
  --url https://ems-mgmt-sandbox.coinapi.io/v1/certificate/pem \
  --header 'Accept: text/plain' \
  --header 'X-CoinAPI-Key: API_KEY'

var client = new RestClient("https://ems-mgmt-sandbox.coinapi.io/v1/certificate/pem");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "text/plain");
request.AddHeader("X-CoinAPI-Key", "API_KEY");
IRestResponse response = client.Execute(request);

package main

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

func main() {

    url := "https://ems-mgmt-sandbox.coinapi.io/v1/certificate/pem"

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

    req.Header.Add("Accept", "text/plain")
    req.Header.Add("X-CoinAPI-Key", "API_KEY")

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

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

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

}

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", "https://ems-mgmt-sandbox.coinapi.io/v1/certificate/pem");
xhr.setRequestHeader("Accept", "text/plain");
xhr.setRequestHeader("X-CoinAPI-Key", "API_KEY");

xhr.send(data);

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://ems-mgmt-sandbox.coinapi.io/v1/certificate/pem",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Accept: text/plain",
    "X-CoinAPI-Key: API_KEY"
  ],
]);

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

curl_close($curl);

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

import http.client

conn = http.client.HTTPSConnection("ems-mgmt-sandbox.coinapi.io")

headers = {
    'Accept': "text/plain",
    'X-CoinAPI-Key': "API_KEY"
    }

conn.request("GET", "/v1/certificate/pem", headers=headers)

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

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

require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://ems-mgmt-sandbox.coinapi.io/v1/certificate/pem")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Get.new(url)
request["Accept"] = 'text/plain'
request["X-CoinAPI-Key"] = 'API_KEY'

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

HttpResponse<String> response = Unirest.get("https://ems-mgmt-sandbox.coinapi.io/v1/certificate/pem")
  .header("Accept", "text/plain")
  .header("X-CoinAPI-Key", "API_KEY")
  .asString();

"-----BEGIN PUBLIC KEY-----\nMIIBIjANB.......\n-----END PUBLIC KEY-----\n-----BEGIN PRIVATE KEY-----\nMIIEvwIAA.......\n-----END PRIVATE KEY-----\n-----BEGIN CERTIFICATE-----\nMIIDEjCCA.......\n-----END CERTIFICATE-----\n"

{
  "exchange_id": "string"
}

{
  "exchange_id": "string",
  "parameters": [
    {
      "key": "PublicApiKey",
      "value": "36279b02-d24f-40be-a61b-e9fd7de46dd6"
    }
  ]
}

{
  "exchange_id": "string",
  "parameters": [
    {
      "key": "PublicApiKey",
      "value": "36279b02-d24f-40be-a61b-e9fd7de46dd6"
    }
  ]
}

{
  "exchange_id": "string",
  "parameters": [
    {
      "key": "PublicApiKey",
      "value": "36279b02-d24f-40be-a61b-e9fd7de46dd6"
    }
  ]
}

{
  "exchange_id": "string",
  "location_id": "string",
  "required_parameters": [
    "string"
  ]
}

{
  "location_id": "aws-us-east-1",
  "region_name": "us-east-1",
  "provider_name": "aws"
}

{
  "key": "PublicApiKey",
  "value": "36279b02-d24f-40be-a61b-e9fd7de46dd6"
}

{
  "exchange_id": "KRAKEN",
  "location_id": "aws-us-east-2",
  "endpoint_schema": "https",
  "endpoint_host": "1314.51253.51.ec2.eu-west-1.amazonaws.com",
  "endpoint_url": "https://1314.51253.51.ec2.eu-west-1.amazonaws.com/"
}

curl --request GET \
  --url https://ems-gateway-aws-eu-central-1-dev.coinapi.io/v1/orders \
  --header 'Accept: application/json'

var client = new RestClient("https://ems-gateway-aws-eu-central-1-dev.coinapi.io/v1/orders");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
IRestResponse response = client.Execute(request);

package main

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

func main() {

    url := "https://ems-gateway-aws-eu-central-1-dev.coinapi.io/v1/orders"

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

    req.Header.Add("Accept", "application/json")

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

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

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

}

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", "https://ems-gateway-aws-eu-central-1-dev.coinapi.io/v1/orders");
xhr.setRequestHeader("Accept", "application/json");

xhr.send(data);

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://ems-gateway-aws-eu-central-1-dev.coinapi.io/v1/orders",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Accept: application/json"
  ],
]);

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

curl_close($curl);

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

import http.client

conn = http.client.HTTPSConnection("ems-gateway-aws-eu-central-1-dev.coinapi.io")

headers = { 'Accept': "application/json" }

conn.request("GET", "/v1/orders", headers=headers)

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

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