NAV Navigation
Bash PHP JavaScript Go Ruby Python Java Kotlin iOS R C#

DEV.ME API Documentation v1.0.0

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

DEV.ME API Documentation Currency Conversion and Exchange Rates API - IP2Location, IP Country, IP Information API - Email Validation, Mailbox Verification - Phone Number Validation. You can learn more at dev.me. For this example you can use api key demo-key to test the APIs

Base URLs:

Terms of service Email: DEV.ME Team Web: DEV.ME Team License: Proprietary license

Authentication

Country

Country Details, Information and Facts APIs

Country APIs

V1GetCountryDetails

Code samples

curl --request GET \
  --url 'https://api.dev.me/v1-get-country-details?code=string' \
  --header 'Accept: application/json' \
  --header 'x-api-key: demo-key'

require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.dev.me/v1-get-country-details?code=string', [
  'headers' => [
    'Accept' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();
import axios from "axios";

const options = {
  method: 'GET',
  url: 'https://api.dev.me/v1-get-country-details',
  params: {code: 'string'},
  headers: {Accept: 'application/json', 'x-api-key': 'demo-key'}
};

axios.request(options).then(function (response) {
  console.log(response.data);
}).catch(function (error) {
  console.error(error);
});
package main

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

func main() {

	url := "https://api.dev.me/v1-get-country-details?code=string"

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

	req.Header.Add("Accept", "application/json")
	req.Header.Add("x-api-key", "demo-key")

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

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

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

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

url = URI("https://api.dev.me/v1-get-country-details?code=string")

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

request = Net::HTTP::Get.new(url)
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'

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

url = "https://api.dev.me/v1-get-country-details?code=string"

headers = {
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("GET", url, headers=headers)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://api.dev.me/v1-get-country-details?code=string")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val request = Request.Builder()
  .url("https://api.dev.me/v1-get-country-details?code=string")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

let headers = [
  "Accept": "application/json",
  "x-api-key": "demo-key"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-get-country-details?code=string")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-get-country-details?code=string");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
IRestResponse response = client.Execute(request);

GET /v1-get-country-details

Get country facts and information

Parameters

Name In Type Required Description
code query string true code - country code ISO 4217
expand query array[string] false expand - expand properties
exclude query array[string] false exclude - exclude properties
language query string false language - localisation language

Enumerated Values

Parameter Value
language en
language ar
language de
language es
language fr
language ja
language ko
language pt
language ru

Example responses

200 Response

{
  "code": "string",
  "name": "string"
}

Responses

Status Meaning Description Schema
200 OK country details response GetCountryDetailsOut
400 Bad Request invalid request HttpErrorOut
401 Unauthorized unauthorized request HttpErrorOut

V1ListCountries

Code samples

curl --request GET \
  --url https://api.dev.me/v1-list-countries \
  --header 'Accept: application/json' \
  --header 'x-api-key: demo-key'

require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.dev.me/v1-list-countries', [
  'headers' => [
    'Accept' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();
import axios from "axios";

const options = {
  method: 'GET',
  url: 'https://api.dev.me/v1-list-countries',
  headers: {Accept: 'application/json', 'x-api-key': 'demo-key'}
};

axios.request(options).then(function (response) {
  console.log(response.data);
}).catch(function (error) {
  console.error(error);
});
package main

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

func main() {

	url := "https://api.dev.me/v1-list-countries"

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

	req.Header.Add("Accept", "application/json")
	req.Header.Add("x-api-key", "demo-key")

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

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

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

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

url = URI("https://api.dev.me/v1-list-countries")

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

request = Net::HTTP::Get.new(url)
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'

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

url = "https://api.dev.me/v1-list-countries"

headers = {
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("GET", url, headers=headers)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://api.dev.me/v1-list-countries")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val request = Request.Builder()
  .url("https://api.dev.me/v1-list-countries")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

let headers = [
  "Accept": "application/json",
  "x-api-key": "demo-key"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-list-countries")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()
library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-list-countries");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
IRestResponse response = client.Execute(request);

GET /v1-list-countries

Get list of all countries

Parameters

Name In Type Required Description
code query array[string] false code - country code ISO 4217
expand query array[string] false expand - expand properties
exclude query array[string] false exclude - exclude properties
language query string false language - localisation language
sort query array[string] false sort - sort properties
page query string false page - page number
pageSize query string false pageSize - page size

Enumerated Values

Parameter Value
language en
language ar
language de
language es
language fr
language ja
language ko
language pt
language ru

Example responses

200 Response

{
  "page": 0,
  "total": 0,
  "list": [
    {
      "code": "string",
      "name": {}
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK list countries response ListCountriesOut
400 Bad Request invalid request HttpErrorOut
401 Unauthorized unauthorized request HttpErrorOut

Currency

Currency Conversion & Exchange Rate APIs

Currency APIs

V1ConvertCurrency

Code samples

curl --request GET \
  --url 'https://api.dev.me/v1-convert-currency?from=string&to=string' \
  --header 'Accept: application/json' \
  --header 'x-api-key: demo-key'

require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.dev.me/v1-convert-currency?from=string&to=string', [
  'headers' => [
    'Accept' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();
import axios from "axios";

const options = {
  method: 'GET',
  url: 'https://api.dev.me/v1-convert-currency',
  params: {from: 'string', to: 'string'},
  headers: {Accept: 'application/json', 'x-api-key': 'demo-key'}
};

axios.request(options).then(function (response) {
  console.log(response.data);
}).catch(function (error) {
  console.error(error);
});
package main

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

func main() {

	url := "https://api.dev.me/v1-convert-currency?from=string&to=string"

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

	req.Header.Add("Accept", "application/json")
	req.Header.Add("x-api-key", "demo-key")

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

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

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

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

url = URI("https://api.dev.me/v1-convert-currency?from=string&to=string")

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

request = Net::HTTP::Get.new(url)
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'

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

url = "https://api.dev.me/v1-convert-currency?from=string&to=string"

headers = {
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("GET", url, headers=headers)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://api.dev.me/v1-convert-currency?from=string&to=string")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val request = Request.Builder()
  .url("https://api.dev.me/v1-convert-currency?from=string&to=string")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

let headers = [
  "Accept": "application/json",
  "x-api-key": "demo-key"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-convert-currency?from=string&to=string")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-convert-currency?from=string&to=string");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
IRestResponse response = client.Execute(request);

GET /v1-convert-currency

Convert currency to another currency

Parameters

Name In Type Required Description
amount query number false amount - amount to convert
from query string true from - currency to convert from
to query string true to - currency to convert to

Example responses

200 Response

{
  "from": "string",
  "to": "string",
  "exchangeRate": 0,
  "rateTime": "string",
  "originalAmount": 0,
  "convertedAmount": 0,
  "convertedText": "string"
}

Responses

Status Meaning Description Schema
200 OK convert currency response ConvertCurrencyOut
400 Bad Request invalid request HttpErrorOut
401 Unauthorized unauthorized request HttpErrorOut

V1GetCurrencyDetails

Code samples

curl --request GET \
  --url 'https://api.dev.me/v1-get-currency-details?code=string' \
  --header 'Accept: application/json' \
  --header 'x-api-key: demo-key'

require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.dev.me/v1-get-currency-details?code=string', [
  'headers' => [
    'Accept' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();
import axios from "axios";

const options = {
  method: 'GET',
  url: 'https://api.dev.me/v1-get-currency-details',
  params: {code: 'string'},
  headers: {Accept: 'application/json', 'x-api-key': 'demo-key'}
};

axios.request(options).then(function (response) {
  console.log(response.data);
}).catch(function (error) {
  console.error(error);
});
package main

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

func main() {

	url := "https://api.dev.me/v1-get-currency-details?code=string"

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

	req.Header.Add("Accept", "application/json")
	req.Header.Add("x-api-key", "demo-key")

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

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

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

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

url = URI("https://api.dev.me/v1-get-currency-details?code=string")

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

request = Net::HTTP::Get.new(url)
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'

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

url = "https://api.dev.me/v1-get-currency-details?code=string"

headers = {
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("GET", url, headers=headers)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://api.dev.me/v1-get-currency-details?code=string")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val request = Request.Builder()
  .url("https://api.dev.me/v1-get-currency-details?code=string")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

let headers = [
  "Accept": "application/json",
  "x-api-key": "demo-key"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-get-currency-details?code=string")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-get-currency-details?code=string");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
IRestResponse response = client.Execute(request);

GET /v1-get-currency-details

Get currency facts and information

Parameters

Name In Type Required Description
code query string true code - currency code ISO 4217
expand query array[string] false expand - expand properties
exclude query array[string] false exclude - exclude properties
language query string false language - localisation language
type query string false type - type of currency

Enumerated Values

Parameter Value
language en
language ar
language de
language es
language fr
language ja
language ko
language pt
language ru
type fiat
type crypto

Example responses

200 Response

{
  "code": "string",
  "name": "string"
}

Responses

Status Meaning Description Schema
200 OK currency details response GetCurrencyDetailsOut
400 Bad Request invalid request HttpErrorOut
401 Unauthorized unauthorized request HttpErrorOut

V1GetCurrencyExchangeRate

Code samples

curl --request GET \
  --url 'https://api.dev.me/v1-get-currency-exchange-rate?from=string&to=string' \
  --header 'Accept: application/json' \
  --header 'x-api-key: demo-key'

require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.dev.me/v1-get-currency-exchange-rate?from=string&to=string', [
  'headers' => [
    'Accept' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();
import axios from "axios";

const options = {
  method: 'GET',
  url: 'https://api.dev.me/v1-get-currency-exchange-rate',
  params: {from: 'string', to: 'string'},
  headers: {Accept: 'application/json', 'x-api-key': 'demo-key'}
};

axios.request(options).then(function (response) {
  console.log(response.data);
}).catch(function (error) {
  console.error(error);
});
package main

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

func main() {

	url := "https://api.dev.me/v1-get-currency-exchange-rate?from=string&to=string"

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

	req.Header.Add("Accept", "application/json")
	req.Header.Add("x-api-key", "demo-key")

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

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

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

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

url = URI("https://api.dev.me/v1-get-currency-exchange-rate?from=string&to=string")

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

request = Net::HTTP::Get.new(url)
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'

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

url = "https://api.dev.me/v1-get-currency-exchange-rate?from=string&to=string"

headers = {
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("GET", url, headers=headers)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://api.dev.me/v1-get-currency-exchange-rate?from=string&to=string")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val request = Request.Builder()
  .url("https://api.dev.me/v1-get-currency-exchange-rate?from=string&to=string")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

let headers = [
  "Accept": "application/json",
  "x-api-key": "demo-key"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-get-currency-exchange-rate?from=string&to=string")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-get-currency-exchange-rate?from=string&to=string");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
IRestResponse response = client.Execute(request);

GET /v1-get-currency-exchange-rate

Get exchange rate for a currency

Parameters

Name In Type Required Description
from query string true from - currency to get exchange rate from
to query string true to - currency to get exchange rate to

Example responses

200 Response

{
  "from": "string",
  "to": "string",
  "exchangeRate": 0,
  "rateTime": "string"
}

Responses

Status Meaning Description Schema
200 OK exchange rate response GetCurrencyExchangeRateOut
400 Bad Request invalid request HttpErrorOut
401 Unauthorized unauthorized request HttpErrorOut

V1ListCurrencies

Code samples

curl --request GET \
  --url https://api.dev.me/v1-list-currencies \
  --header 'Accept: application/json' \
  --header 'x-api-key: demo-key'

require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.dev.me/v1-list-currencies', [
  'headers' => [
    'Accept' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();
import axios from "axios";

const options = {
  method: 'GET',
  url: 'https://api.dev.me/v1-list-currencies',
  headers: {Accept: 'application/json', 'x-api-key': 'demo-key'}
};

axios.request(options).then(function (response) {
  console.log(response.data);
}).catch(function (error) {
  console.error(error);
});
package main

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

func main() {

	url := "https://api.dev.me/v1-list-currencies"

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

	req.Header.Add("Accept", "application/json")
	req.Header.Add("x-api-key", "demo-key")

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

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

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

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

url = URI("https://api.dev.me/v1-list-currencies")

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

request = Net::HTTP::Get.new(url)
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'

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

url = "https://api.dev.me/v1-list-currencies"

headers = {
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("GET", url, headers=headers)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://api.dev.me/v1-list-currencies")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val request = Request.Builder()
  .url("https://api.dev.me/v1-list-currencies")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

let headers = [
  "Accept": "application/json",
  "x-api-key": "demo-key"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-list-currencies")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-list-currencies");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
IRestResponse response = client.Execute(request);

GET /v1-list-currencies

Get list of all currencies

Parameters

Name In Type Required Description
code query array[string] false code - currency code ISO 4217
expand query array[string] false expand - expand properties
exclude query array[string] false exclude - exclude properties
language query string false language - localisation language
type query string false type - type of currency
sort query array[string] false sort - sort properties
page query string false page - page number
pageSize query string false pageSize - page size

Enumerated Values

Parameter Value
language en
language ar
language de
language es
language fr
language ja
language ko
language pt
language ru
type fiat
type crypto

Example responses

200 Response

{
  "page": 0,
  "total": 0,
  "list": [
    {
      "code": "string",
      "banknotes": {},
      "coins": {},
      "iso": {},
      "name": {},
      "type": "fiat",
      "units": {}
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK list currencies response ListCurrenciesOut
400 Bad Request invalid request HttpErrorOut
401 Unauthorized unauthorized request HttpErrorOut

Domain

Domain Tools APIs

Domain APIs

V1GetDomainWhois

Code samples

curl --request GET \
  --url https://api.dev.me/v1-get-domain-whois \
  --header 'Accept: application/json' \
  --header 'x-api-key: demo-key'

require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.dev.me/v1-get-domain-whois', [
  'headers' => [
    'Accept' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();
import axios from "axios";

const options = {
  method: 'GET',
  url: 'https://api.dev.me/v1-get-domain-whois',
  headers: {Accept: 'application/json', 'x-api-key': 'demo-key'}
};

axios.request(options).then(function (response) {
  console.log(response.data);
}).catch(function (error) {
  console.error(error);
});
package main

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

func main() {

	url := "https://api.dev.me/v1-get-domain-whois"

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

	req.Header.Add("Accept", "application/json")
	req.Header.Add("x-api-key", "demo-key")

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

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

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

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

url = URI("https://api.dev.me/v1-get-domain-whois")

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

request = Net::HTTP::Get.new(url)
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'

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

url = "https://api.dev.me/v1-get-domain-whois"

headers = {
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("GET", url, headers=headers)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://api.dev.me/v1-get-domain-whois")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val request = Request.Builder()
  .url("https://api.dev.me/v1-get-domain-whois")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

let headers = [
  "Accept": "application/json",
  "x-api-key": "demo-key"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-get-domain-whois")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-get-domain-whois");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
IRestResponse response = client.Execute(request);

GET /v1-get-domain-whois

Get domain WHOIS details and registration information

Parameters

Name In Type Required Description
domain query string false domain - Domain name to get details for

Example responses

200 Response

{
  "domain": "string",
  "details": "string"
}

Responses

Status Meaning Description Schema
200 OK get domain whois response GetDomainWhoisOut
400 Bad Request invalid request HttpErrorOut
401 Unauthorized unauthorized request HttpErrorOut

Email

Reliable and Accurate Mailbox Verification APIs

Email APIs

V1GetEmailDetails

Code samples

curl --request GET \
  --url 'https://api.dev.me/v1-get-email-details?email=string' \
  --header 'Accept: application/json' \
  --header 'x-api-key: demo-key'

require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.dev.me/v1-get-email-details?email=string', [
  'headers' => [
    'Accept' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();
import axios from "axios";

const options = {
  method: 'GET',
  url: 'https://api.dev.me/v1-get-email-details',
  params: {email: 'string'},
  headers: {Accept: 'application/json', 'x-api-key': 'demo-key'}
};

axios.request(options).then(function (response) {
  console.log(response.data);
}).catch(function (error) {
  console.error(error);
});
package main

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

func main() {

	url := "https://api.dev.me/v1-get-email-details?email=string"

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

	req.Header.Add("Accept", "application/json")
	req.Header.Add("x-api-key", "demo-key")

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

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

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

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

url = URI("https://api.dev.me/v1-get-email-details?email=string")

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

request = Net::HTTP::Get.new(url)
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'

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

url = "https://api.dev.me/v1-get-email-details?email=string"

headers = {
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("GET", url, headers=headers)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://api.dev.me/v1-get-email-details?email=string")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val request = Request.Builder()
  .url("https://api.dev.me/v1-get-email-details?email=string")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

let headers = [
  "Accept": "application/json",
  "x-api-key": "demo-key"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-get-email-details?email=string")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-get-email-details?email=string");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
IRestResponse response = client.Execute(request);

GET /v1-get-email-details

Get email validation details

Parameters

Name In Type Required Description
email query string true email - email address
checkDns query boolean false checkDns - check dns for MX record

Example responses

200 Response

{
  "email": "string",
  "validDomain": true,
  "validMailbox": true,
  "validFormat": true,
  "isDisposable": true,
  "isFree": true,
  "domainAge": 0,
  "score": 0
}

Responses

Status Meaning Description Schema
200 OK get email details response GetEmailDetailsOut
400 Bad Request invalid request HttpErrorOut
401 Unauthorized unauthorized request HttpErrorOut

IP

IP2Location and IP GeoLocation Data APIs

IP APIs

V1GetIpDetails

Code samples

curl --request GET \
  --url https://api.dev.me/v1-get-ip-details \
  --header 'Accept: application/json' \
  --header 'x-api-key: demo-key'

require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.dev.me/v1-get-ip-details', [
  'headers' => [
    'Accept' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();
import axios from "axios";

const options = {
  method: 'GET',
  url: 'https://api.dev.me/v1-get-ip-details',
  headers: {Accept: 'application/json', 'x-api-key': 'demo-key'}
};

axios.request(options).then(function (response) {
  console.log(response.data);
}).catch(function (error) {
  console.error(error);
});
package main

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

func main() {

	url := "https://api.dev.me/v1-get-ip-details"

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

	req.Header.Add("Accept", "application/json")
	req.Header.Add("x-api-key", "demo-key")

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

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

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

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

url = URI("https://api.dev.me/v1-get-ip-details")

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

request = Net::HTTP::Get.new(url)
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'

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

url = "https://api.dev.me/v1-get-ip-details"

headers = {
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("GET", url, headers=headers)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://api.dev.me/v1-get-ip-details")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val request = Request.Builder()
  .url("https://api.dev.me/v1-get-ip-details")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

let headers = [
  "Accept": "application/json",
  "x-api-key": "demo-key"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-get-ip-details")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()
library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-get-ip-details");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
IRestResponse response = client.Execute(request);

GET /v1-get-ip-details

Get IP GEO Location and ISP details

Parameters

Name In Type Required Description
ip query string false ip - IP Address

Example responses

200 Response

{
  "ip": "string",
  "countryCode": "string",
  "registeredCountryCode": "string",
  "asn": "string",
  "aso": "string",
  "city": {
    "accuracyRadius": 0,
    "latitude": 0,
    "longitude": "string",
    "timeZone": "string",
    "name": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK get ip details response GetIpDetailsOut
400 Bad Request invalid request HttpErrorOut
401 Unauthorized unauthorized request HttpErrorOut

Phone

Global Phone Number Validation & Lookup JSON APIs

Phone APIs

V1GetPhoneDetails

Code samples

curl --request GET \
  --url 'https://api.dev.me/v1-get-phone-details?phone=string' \
  --header 'Accept: application/json' \
  --header 'x-api-key: demo-key'

require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.dev.me/v1-get-phone-details?phone=string', [
  'headers' => [
    'Accept' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();
import axios from "axios";

const options = {
  method: 'GET',
  url: 'https://api.dev.me/v1-get-phone-details',
  params: {phone: 'string'},
  headers: {Accept: 'application/json', 'x-api-key': 'demo-key'}
};

axios.request(options).then(function (response) {
  console.log(response.data);
}).catch(function (error) {
  console.error(error);
});
package main

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

func main() {

	url := "https://api.dev.me/v1-get-phone-details?phone=string"

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

	req.Header.Add("Accept", "application/json")
	req.Header.Add("x-api-key", "demo-key")

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

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

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

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

url = URI("https://api.dev.me/v1-get-phone-details?phone=string")

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

request = Net::HTTP::Get.new(url)
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'

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

url = "https://api.dev.me/v1-get-phone-details?phone=string"

headers = {
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("GET", url, headers=headers)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://api.dev.me/v1-get-phone-details?phone=string")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val request = Request.Builder()
  .url("https://api.dev.me/v1-get-phone-details?phone=string")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

let headers = [
  "Accept": "application/json",
  "x-api-key": "demo-key"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-get-phone-details?phone=string")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-get-phone-details?phone=string");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
IRestResponse response = client.Execute(request);

GET /v1-get-phone-details

Get phone validation details

Parameters

Name In Type Required Description
phone query string true phone - phone number to validate

Example responses

200 Response

{
  "number": "string",
  "valid": true,
  "country": "string",
  "callingCode": "string",
  "nationalNumber": "string",
  "type": "string"
}

Responses

Status Meaning Description Schema
200 OK get phone details response GetPhoneDetailsOut
400 Bad Request invalid request HttpErrorOut
401 Unauthorized unauthorized request HttpErrorOut

Utils

Utils

V1WhoAmI

Code samples

curl --request GET \
  --url https://api.dev.me/v1-who-am-i \
  --header 'Accept: application/json' \
  --header 'x-api-key: demo-key'

require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.dev.me/v1-who-am-i', [
  'headers' => [
    'Accept' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();
import axios from "axios";

const options = {
  method: 'GET',
  url: 'https://api.dev.me/v1-who-am-i',
  headers: {Accept: 'application/json', 'x-api-key': 'demo-key'}
};

axios.request(options).then(function (response) {
  console.log(response.data);
}).catch(function (error) {
  console.error(error);
});
package main

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

func main() {

	url := "https://api.dev.me/v1-who-am-i"

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

	req.Header.Add("Accept", "application/json")
	req.Header.Add("x-api-key", "demo-key")

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

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

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

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

url = URI("https://api.dev.me/v1-who-am-i")

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

request = Net::HTTP::Get.new(url)
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'

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

url = "https://api.dev.me/v1-who-am-i"

headers = {
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("GET", url, headers=headers)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://api.dev.me/v1-who-am-i")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val request = Request.Builder()
  .url("https://api.dev.me/v1-who-am-i")
  .get()
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

let headers = [
  "Accept": "application/json",
  "x-api-key": "demo-key"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-who-am-i")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-who-am-i");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
IRestResponse response = client.Execute(request);

GET /v1-who-am-i

Get current user details with api key

Example responses

200 Response

{
  "userId": "string",
  "email": "string",
  "username": "string",
  "reqIpAddress": "string",
  "reqIpCountry": "string",
  "reqUserAgent": "string"
}

Responses

Status Meaning Description Schema
200 OK response WhoAmIOut

Schemas

ConvertCurrencyOut

{
  "from": "string",
  "to": "string",
  "exchangeRate": 0,
  "rateTime": "string",
  "originalAmount": 0,
  "convertedAmount": 0,
  "convertedText": "string"
}

Properties

Name Type Required Restrictions Description
from string false none currency to convert from
to string false none currency to convert to
exchangeRate number false none exchange rate
rateTime string false none time of the exchange rate
originalAmount number false none original amount input
convertedAmount number false none converted amount
convertedText string false none converted amount in text

Error

{
  "value": "string",
  "msg": "string",
  "param": "string",
  "location": "string"
}

Properties

Name Type Required Restrictions Description
value any false none error value

anyOf

Name Type Required Restrictions Description
» anonymous string false none none

or

Name Type Required Restrictions Description
» anonymous number false none none

continued

Name Type Required Restrictions Description
msg string false none error message
param string false none error parameters
location string false none location of the error

GetCountryDetailsOut

{
  "code": "string",
  "name": "string"
}

Properties

Name Type Required Restrictions Description
code string false none country code ISO 4217
name string false none country name

GetCurrencyDetailsOut

{
  "code": "string",
  "name": "string"
}

Properties

Name Type Required Restrictions Description
code string false none currency code ISO 4217
name string false none currency name

GetCurrencyExchangeRateOut

{
  "from": "string",
  "to": "string",
  "exchangeRate": 0,
  "rateTime": "string"
}

Properties

Name Type Required Restrictions Description
from string false none currency to get exchange rate from
to string false none currency to get exchange rate to
exchangeRate number false none exchange rate
rateTime string false none time of the exchange rate

GetDomainWhoisOut

{
  "domain": "string",
  "details": "string"
}

Properties

Name Type Required Restrictions Description
domain string false none Domain name
details string false none Domain details

GetEmailDetailsOut

{
  "email": "string",
  "validDomain": true,
  "validMailbox": true,
  "validFormat": true,
  "isDisposable": true,
  "isFree": true,
  "domainAge": 0,
  "score": 0
}

Properties

Name Type Required Restrictions Description
email string false none email address
validDomain boolean false none is valid domain
validMailbox boolean false none is valid mailbox
validFormat boolean false none is valid format
isDisposable boolean false none is disposable email
isFree boolean false none is free email
domainAge number false none domain age
score number false none quality score

GetIpDetailsCityOut

{
  "accuracyRadius": 0,
  "latitude": 0,
  "longitude": "string",
  "timeZone": "string",
  "name": "string"
}

Properties

Name Type Required Restrictions Description
accuracyRadius number false none Accuracy Radius
latitude number false none Latitude
longitude string false none Longitude
timeZone string false none Time Zone
name string false none City Name

GetIpDetailsOut

{
  "ip": "string",
  "countryCode": "string",
  "registeredCountryCode": "string",
  "asn": "string",
  "aso": "string",
  "city": {
    "accuracyRadius": 0,
    "latitude": 0,
    "longitude": "string",
    "timeZone": "string",
    "name": "string"
  }
}

Properties

Name Type Required Restrictions Description
ip string false none IP Address
countryCode string false none Country Code ISO 3166-1 Alpha-2
registeredCountryCode string false none Registered Country Code ISO 3166-1 Alpha-2
asn string false none autonomous system number
aso string false none autonomous system organization
city GetIpDetailsCityOut false none none

GetPhoneDetailsOut

{
  "number": "string",
  "valid": true,
  "country": "string",
  "callingCode": "string",
  "nationalNumber": "string",
  "type": "string"
}

Properties

Name Type Required Restrictions Description
number string false none phone number
valid boolean false none is phone number valid
country string false none country code associated with phone number ISO 3166-1 alpha-2
callingCode string false none country calling code associated with phone number
nationalNumber string false none national number associated with phone number
type string false none phone number type

HttpErrorOut

{
  "status": 0,
  "name": "string",
  "message": "string",
  "errors": [
    {
      "value": "string",
      "msg": "string",
      "param": "string",
      "location": "string"
    }
  ]
}

Properties

Name Type Required Restrictions Description
status number false none http status code
name string false none error name
message string false none error message
errors [Error] false none array of errors

ListCountriesItem

{
  "code": "string",
  "name": {}
}

Properties

Name Type Required Restrictions Description
code string false none country code ISO 4217
name object false none name

ListCountriesOut

{
  "page": 0,
  "total": 0,
  "list": [
    {
      "code": "string",
      "name": {}
    }
  ]
}

Properties

Name Type Required Restrictions Description
page number false none page number
total number false none total number of countries
list [ListCountriesItem] false none list of countries

ListCurrenciesItem

{
  "code": "string",
  "banknotes": {},
  "coins": {},
  "iso": {},
  "name": {},
  "type": "fiat",
  "units": {}
}

Properties

Name Type Required Restrictions Description
code string false none currency code ISO 4217
banknotes object false none banknotes
coins object false none coins
iso object false none iso
name object false none name
type string false none type of currency
units object false none units

Enumerated Values

Property Value
type fiat
type crypto

ListCurrenciesOut

{
  "page": 0,
  "total": 0,
  "list": [
    {
      "code": "string",
      "banknotes": {},
      "coins": {},
      "iso": {},
      "name": {},
      "type": "fiat",
      "units": {}
    }
  ]
}

Properties

Name Type Required Restrictions Description
page number false none page number
total number false none total number of currencies
list [ListCurrenciesItem] false none list of currencies

WhoAmIOut

{
  "userId": "string",
  "email": "string",
  "username": "string",
  "reqIpAddress": "string",
  "reqIpCountry": "string",
  "reqUserAgent": "string"
}

Properties

Name Type Required Restrictions Description
userId string false none none
email string false none none
username string false none none
reqIpAddress string false none none
reqIpCountry string false none none
reqUserAgent string false none none