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:

https://api.dev.me

Authentication

API Key (APIKeyHeader)
- Parameter Name: x-api-key, in: header.
API Key (APIKeyQueryParam)
- Parameter Name: x-api-key, in: query.

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": {}
}

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
parseWhoisToJson	query	string	false	parseWhoisToJson - Parse WHOIS to JSON

Example responses

200 Response

{
  "domain": "string",
  "whoisText": "string",
  "whoisJson": {}
}

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
verifyMx	query	boolean	false	verifyMx - verify domain dns for MX record
verifySmtp	query	boolean	false	verifySmtp - verify mailbox with SMTP Connect and Reply
timeout	query	string	false	timeout - timeout in milliseconds max 10000 (10 seconds)

Example responses

200 Response

{
  "email": "string",
  "validMx": true,
  "validSmtp": 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": 0,
    "timeZone": "string",
    "areaCode": "string",
    "region": "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

Image

Image Optimization, Transformation and OCR APIs

Images Optimization, Transformation, Placeholder and OCR APIs

V1GetTextFromImage

Code samples

curl --request POST \
  --url https://api.dev.me/v1-get-text-from-image \
  --header 'Accept: application/json' \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: demo-key' \
  --data '
{
  "image": {},
  "url": "string",
  "lang": "string",
  "psm": "string",
  "outputFormat": "string"
}
'


require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.dev.me/v1-get-text-from-image', [
  'body' => '{"image":{},"url":"string","lang":"string","psm":"string","outputFormat":"string"}',
  'headers' => [
    'Accept' => 'application/json',
    'Content-Type' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();

import axios from "axios";

const options = {
  method: 'POST',
  url: 'https://api.dev.me/v1-get-text-from-image',
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json',
    'x-api-key': 'demo-key'
  },
  data: {
    image: {},
    url: 'string',
    lang: 'string',
    psm: 'string',
    outputFormat: 'string'
  }
};

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

package main

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

func main() {

	url := "https://api.dev.me/v1-get-text-from-image"

	payload := strings.NewReader("{\"image\":{},\"url\":\"string\",\"lang\":\"string\",\"psm\":\"string\",\"outputFormat\":\"string\"}")

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

	req.Header.Add("Content-Type", "application/json")
	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-text-from-image")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'
request.body = "{\"image\":{},\"url\":\"string\",\"lang\":\"string\",\"psm\":\"string\",\"outputFormat\":\"string\"}"

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

import requests

url = "https://api.dev.me/v1-get-text-from-image"

payload = {
    "image": {},
    "url": "string",
    "lang": "string",
    "psm": "string",
    "outputFormat": "string"
}
headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("POST", url, json=payload, headers=headers)

print(response.text)

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\"image\":{},\"url\":\"string\",\"lang\":\"string\",\"psm\":\"string\",\"outputFormat\":\"string\"}");
Request request = new Request.Builder()
  .url("https://api.dev.me/v1-get-text-from-image")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\"image\":{},\"url\":\"string\",\"lang\":\"string\",\"psm\":\"string\",\"outputFormat\":\"string\"}")
val request = Request.Builder()
  .url("https://api.dev.me/v1-get-text-from-image")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

import Foundation

let headers = [
  "Content-Type": "application/json",
  "Accept": "application/json",
  "x-api-key": "demo-key"
]
let parameters = [
  "image": [],
  "url": "string",
  "lang": "string",
  "psm": "string",
  "outputFormat": "string"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-get-text-from-image")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-get-text-from-image");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
request.AddParameter("application/json", "{\"image\":{},\"url\":\"string\",\"lang\":\"string\",\"psm\":\"string\",\"outputFormat\":\"string\"}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

POST /v1-get-text-from-image

Get Text From Image with OCR

Body parameter

{
  "image": {},
  "url": "string",
  "lang": "string",
  "psm": "string",
  "outputFormat": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	GetTextFromImageIn	true	body

Example responses

200 Response

{
  "text": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	get text from image response	GetTextFromImageOut
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",
  "isDisposable": true
}

Responses

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

ShortUrl

Url Shortener API

URL Shortener APIs

V1CreateShortUrl

Code samples

curl --request POST \
  --url https://api.dev.me/v1-create-short-url \
  --header 'Accept: application/json' \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: demo-key' \
  --data '
{
  "url": "string",
  "domain": "string"
}
'


require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.dev.me/v1-create-short-url', [
  'body' => '{"url":"string","domain":"string"}',
  'headers' => [
    'Accept' => 'application/json',
    'Content-Type' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();

import axios from "axios";

const options = {
  method: 'POST',
  url: 'https://api.dev.me/v1-create-short-url',
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json',
    'x-api-key': 'demo-key'
  },
  data: {url: 'string', domain: 'string'}
};

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

package main

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

func main() {

	url := "https://api.dev.me/v1-create-short-url"

	payload := strings.NewReader("{\"url\":\"string\",\"domain\":\"string\"}")

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

	req.Header.Add("Content-Type", "application/json")
	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-create-short-url")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'
request.body = "{\"url\":\"string\",\"domain\":\"string\"}"

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

import requests

url = "https://api.dev.me/v1-create-short-url"

payload = {
    "url": "string",
    "domain": "string"
}
headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("POST", url, json=payload, headers=headers)

print(response.text)

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\"url\":\"string\",\"domain\":\"string\"}");
Request request = new Request.Builder()
  .url("https://api.dev.me/v1-create-short-url")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\"url\":\"string\",\"domain\":\"string\"}")
val request = Request.Builder()
  .url("https://api.dev.me/v1-create-short-url")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

import Foundation

let headers = [
  "Content-Type": "application/json",
  "Accept": "application/json",
  "x-api-key": "demo-key"
]
let parameters = [
  "url": "string",
  "domain": "string"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-create-short-url")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-create-short-url");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
request.AddParameter("application/json", "{\"url\":\"string\",\"domain\":\"string\"}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

POST /v1-create-short-url

Create a short URL from a long URL

Body parameter

{
  "url": "string",
  "domain": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	CreateShortUrlIn	true	none

Example responses

200 Response

{
  "url": "string",
  "shortUrl": "string",
  "sid": "string",
  "createdAt": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	create short url response	CreateShortUrlOut
400	Bad Request	invalid request	HttpErrorOut
401	Unauthorized	unauthorized request	HttpErrorOut

V1DeleteShortUrl

Code samples

curl --request POST \
  --url https://api.dev.me/v1-delete-short-url \
  --header 'Accept: application/json' \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: demo-key' \
  --data '
{
  "sid": "string",
  "domain": "string"
}
'


require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.dev.me/v1-delete-short-url', [
  'body' => '{"sid":"string","domain":"string"}',
  'headers' => [
    'Accept' => 'application/json',
    'Content-Type' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();

import axios from "axios";

const options = {
  method: 'POST',
  url: 'https://api.dev.me/v1-delete-short-url',
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json',
    'x-api-key': 'demo-key'
  },
  data: {sid: 'string', domain: 'string'}
};

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

package main

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

func main() {

	url := "https://api.dev.me/v1-delete-short-url"

	payload := strings.NewReader("{\"sid\":\"string\",\"domain\":\"string\"}")

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

	req.Header.Add("Content-Type", "application/json")
	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-delete-short-url")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'
request.body = "{\"sid\":\"string\",\"domain\":\"string\"}"

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

import requests

url = "https://api.dev.me/v1-delete-short-url"

payload = {
    "sid": "string",
    "domain": "string"
}
headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("POST", url, json=payload, headers=headers)

print(response.text)

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\"sid\":\"string\",\"domain\":\"string\"}");
Request request = new Request.Builder()
  .url("https://api.dev.me/v1-delete-short-url")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\"sid\":\"string\",\"domain\":\"string\"}")
val request = Request.Builder()
  .url("https://api.dev.me/v1-delete-short-url")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

import Foundation

let headers = [
  "Content-Type": "application/json",
  "Accept": "application/json",
  "x-api-key": "demo-key"
]
let parameters = [
  "sid": "string",
  "domain": "string"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-delete-short-url")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-delete-short-url");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
request.AddParameter("application/json", "{\"sid\":\"string\",\"domain\":\"string\"}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

POST /v1-delete-short-url

Create a short URL from a long URL

Body parameter

{
  "sid": "string",
  "domain": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	DeleteShortUrlIn	true	none

Example responses

200 Response

{
  "success": true
}

Responses

Status	Meaning	Description	Schema
200	OK	response	DeleteShortUrlOut

V1GetShortUrlDetails

Code samples

curl --request GET \
  --url https://api.dev.me/v1-get-short-url-details \
  --header 'Accept: short url details' \
  --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-short-url-details', [
  'headers' => [
    'Accept' => 'short url details',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();

import axios from "axios";

const options = {
  method: 'GET',
  url: 'https://api.dev.me/v1-get-short-url-details',
  headers: {Accept: 'short url details', '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-short-url-details"

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

	req.Header.Add("Accept", "short url details")
	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-short-url-details")

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

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

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

import requests

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

headers = {
    "Accept": "short url details",
    "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-short-url-details")
  .get()
  .addHeader("Accept", "short url details")
  .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-short-url-details")
  .get()
  .addHeader("Accept", "short url details")
  .addHeader("x-api-key", "demo-key")
  .build()

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

import Foundation

let headers = [
  "Accept": "short url details",
  "x-api-key": "demo-key"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-get-short-url-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-short-url-details");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "short url details");
request.AddHeader("x-api-key", "demo-key");
IRestResponse response = client.Execute(request);

GET /v1-get-short-url-details

Create a short URL from a long URL

Parameters

Name	In	Type	Required	Description
sid	query	string	false	sid - short url sid
domain	query	string	false	domain - domain name for short url
_id	query	string	false	_id - short url id

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	response	GetShortUrlDetailsOut

V1UpdateShortUrl

Code samples

curl --request POST \
  --url https://api.dev.me/v1-update-short-url \
  --header 'Accept: application/json' \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: demo-key' \
  --data '
{
  "_id": "string",
  "sid": "string",
  "domain": "string"
}
'


require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.dev.me/v1-update-short-url', [
  'body' => '{"_id":"string","sid":"string","domain":"string"}',
  'headers' => [
    'Accept' => 'application/json',
    'Content-Type' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();

import axios from "axios";

const options = {
  method: 'POST',
  url: 'https://api.dev.me/v1-update-short-url',
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json',
    'x-api-key': 'demo-key'
  },
  data: {_id: 'string', sid: 'string', domain: 'string'}
};

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

package main

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

func main() {

	url := "https://api.dev.me/v1-update-short-url"

	payload := strings.NewReader("{\"_id\":\"string\",\"sid\":\"string\",\"domain\":\"string\"}")

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

	req.Header.Add("Content-Type", "application/json")
	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-update-short-url")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'
request.body = "{\"_id\":\"string\",\"sid\":\"string\",\"domain\":\"string\"}"

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

import requests

url = "https://api.dev.me/v1-update-short-url"

payload = {
    "_id": "string",
    "sid": "string",
    "domain": "string"
}
headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("POST", url, json=payload, headers=headers)

print(response.text)

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\"_id\":\"string\",\"sid\":\"string\",\"domain\":\"string\"}");
Request request = new Request.Builder()
  .url("https://api.dev.me/v1-update-short-url")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\"_id\":\"string\",\"sid\":\"string\",\"domain\":\"string\"}")
val request = Request.Builder()
  .url("https://api.dev.me/v1-update-short-url")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

import Foundation

let headers = [
  "Content-Type": "application/json",
  "Accept": "application/json",
  "x-api-key": "demo-key"
]
let parameters = [
  "_id": "string",
  "sid": "string",
  "domain": "string"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-update-short-url")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-update-short-url");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
request.AddParameter("application/json", "{\"_id\":\"string\",\"sid\":\"string\",\"domain\":\"string\"}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

POST /v1-update-short-url

Create a short URL from a long URL

Body parameter

{
  "_id": "string",
  "sid": "string",
  "domain": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	UpdateShortUrlIn	true	none

Example responses

200 Response

{
  "originalUrl": "string",
  "shortUrl": "string",
  "sid": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	response	UpdateShortUrlOut

OnetimeUrl

OneTime URL API

OneTime URL APIs

V1CreateOnetimeUrl

Code samples

curl --request POST \
  --url https://api.dev.me/v1-create-onetime-url \
  --header 'Accept: application/json' \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: demo-key' \
  --data '
{
  "text": "string",
  "passphrase": "string",
  "lifetime": "string",
  "domain": "string"
}
'


require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.dev.me/v1-create-onetime-url', [
  'body' => '{"text":"string","passphrase":"string","lifetime":"string","domain":"string"}',
  'headers' => [
    'Accept' => 'application/json',
    'Content-Type' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();

import axios from "axios";

const options = {
  method: 'POST',
  url: 'https://api.dev.me/v1-create-onetime-url',
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json',
    'x-api-key': 'demo-key'
  },
  data: {text: 'string', passphrase: 'string', lifetime: 'string', domain: 'string'}
};

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

package main

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

func main() {

	url := "https://api.dev.me/v1-create-onetime-url"

	payload := strings.NewReader("{\"text\":\"string\",\"passphrase\":\"string\",\"lifetime\":\"string\",\"domain\":\"string\"}")

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

	req.Header.Add("Content-Type", "application/json")
	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-create-onetime-url")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'
request.body = "{\"text\":\"string\",\"passphrase\":\"string\",\"lifetime\":\"string\",\"domain\":\"string\"}"

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

import requests

url = "https://api.dev.me/v1-create-onetime-url"

payload = {
    "text": "string",
    "passphrase": "string",
    "lifetime": "string",
    "domain": "string"
}
headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("POST", url, json=payload, headers=headers)

print(response.text)

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\"text\":\"string\",\"passphrase\":\"string\",\"lifetime\":\"string\",\"domain\":\"string\"}");
Request request = new Request.Builder()
  .url("https://api.dev.me/v1-create-onetime-url")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\"text\":\"string\",\"passphrase\":\"string\",\"lifetime\":\"string\",\"domain\":\"string\"}")
val request = Request.Builder()
  .url("https://api.dev.me/v1-create-onetime-url")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

import Foundation

let headers = [
  "Content-Type": "application/json",
  "Accept": "application/json",
  "x-api-key": "demo-key"
]
let parameters = [
  "text": "string",
  "passphrase": "string",
  "lifetime": "string",
  "domain": "string"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-create-onetime-url")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-create-onetime-url");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
request.AddParameter("application/json", "{\"text\":\"string\",\"passphrase\":\"string\",\"lifetime\":\"string\",\"domain\":\"string\"}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

POST /v1-create-onetime-url

Create a onetime URL from a long URL

Body parameter

{
  "text": "string",
  "passphrase": "string",
  "lifetime": "string",
  "domain": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	CreateOnetimeUrlIn	true	none

Example responses

200 Response

{
  "onetimeUrl": "string",
  "sid": "string",
  "createdAt": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	create onetime url response	CreateOnetimeUrlOut
400	Bad Request	invalid request	HttpErrorOut
401	Unauthorized	unauthorized request	HttpErrorOut

V1DeleteOnetimeUrl

Code samples

curl --request POST \
  --url https://api.dev.me/v1-delete-onetime-url \
  --header 'Accept: application/json' \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: demo-key' \
  --data '
{
  "sid": "string",
  "domain": "string",
  "passphrase": "string"
}
'


require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.dev.me/v1-delete-onetime-url', [
  'body' => '{"sid":"string","domain":"string","passphrase":"string"}',
  'headers' => [
    'Accept' => 'application/json',
    'Content-Type' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();

import axios from "axios";

const options = {
  method: 'POST',
  url: 'https://api.dev.me/v1-delete-onetime-url',
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json',
    'x-api-key': 'demo-key'
  },
  data: {sid: 'string', domain: 'string', passphrase: 'string'}
};

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

package main

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

func main() {

	url := "https://api.dev.me/v1-delete-onetime-url"

	payload := strings.NewReader("{\"sid\":\"string\",\"domain\":\"string\",\"passphrase\":\"string\"}")

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

	req.Header.Add("Content-Type", "application/json")
	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-delete-onetime-url")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'
request.body = "{\"sid\":\"string\",\"domain\":\"string\",\"passphrase\":\"string\"}"

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

import requests

url = "https://api.dev.me/v1-delete-onetime-url"

payload = {
    "sid": "string",
    "domain": "string",
    "passphrase": "string"
}
headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("POST", url, json=payload, headers=headers)

print(response.text)

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\"sid\":\"string\",\"domain\":\"string\",\"passphrase\":\"string\"}");
Request request = new Request.Builder()
  .url("https://api.dev.me/v1-delete-onetime-url")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\"sid\":\"string\",\"domain\":\"string\",\"passphrase\":\"string\"}")
val request = Request.Builder()
  .url("https://api.dev.me/v1-delete-onetime-url")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

import Foundation

let headers = [
  "Content-Type": "application/json",
  "Accept": "application/json",
  "x-api-key": "demo-key"
]
let parameters = [
  "sid": "string",
  "domain": "string",
  "passphrase": "string"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-delete-onetime-url")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-delete-onetime-url");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
request.AddParameter("application/json", "{\"sid\":\"string\",\"domain\":\"string\",\"passphrase\":\"string\"}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

POST /v1-delete-onetime-url

Create a onetime URL from a long URL

Body parameter

{
  "sid": "string",
  "domain": "string",
  "passphrase": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	DeleteOnetimeUrlIn	true	none

Example responses

200 Response

{
  "success": true
}

Responses

Status	Meaning	Description	Schema
200	OK	response	DeleteOnetimeUrlOut

V1GetOnetimeUrlDetails

Code samples

curl --request GET \
  --url https://api.dev.me/v1-get-onetime-url-details \
  --header 'Accept: onetime url details' \
  --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-onetime-url-details', [
  'headers' => [
    'Accept' => 'onetime url details',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();

import axios from "axios";

const options = {
  method: 'GET',
  url: 'https://api.dev.me/v1-get-onetime-url-details',
  headers: {Accept: 'onetime url details', '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-onetime-url-details"

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

	req.Header.Add("Accept", "onetime url details")
	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-onetime-url-details")

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

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

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

import requests

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

headers = {
    "Accept": "onetime url details",
    "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-onetime-url-details")
  .get()
  .addHeader("Accept", "onetime url details")
  .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-onetime-url-details")
  .get()
  .addHeader("Accept", "onetime url details")
  .addHeader("x-api-key", "demo-key")
  .build()

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

import Foundation

let headers = [
  "Accept": "onetime url details",
  "x-api-key": "demo-key"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-get-onetime-url-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-onetime-url-details");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "onetime url details");
request.AddHeader("x-api-key", "demo-key");
IRestResponse response = client.Execute(request);

GET /v1-get-onetime-url-details

Create a onetime URL from a long URL

Parameters

Name	In	Type	Required	Description
sid	query	string	false	sid - onetime url sid
_id	query	string	false	_id - onetime url id
domain	query	string	false	domain - custom domain name if allowed by the user
passphrase	query	string	false	passphrase - passphrase

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	response	GetOnetimeUrlDetailsOut

UrlScraper

Scraper URL, Capture URL Screenshot, Extract Metadata and OpenGraph Data from URL API

V1CaptureUrlScreenshot

Code samples

curl --request POST \
  --url https://api.dev.me/v1-capture-url-screenshot \
  --header 'Accept: application/json' \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: demo-key' \
  --data '
{
  "url": "string",
  "includeHtml": true
}
'


require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.dev.me/v1-capture-url-screenshot', [
  'body' => '{"url":"string","includeHtml":true}',
  'headers' => [
    'Accept' => 'application/json',
    'Content-Type' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();

import axios from "axios";

const options = {
  method: 'POST',
  url: 'https://api.dev.me/v1-capture-url-screenshot',
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json',
    'x-api-key': 'demo-key'
  },
  data: {url: 'string', includeHtml: true}
};

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

package main

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

func main() {

	url := "https://api.dev.me/v1-capture-url-screenshot"

	payload := strings.NewReader("{\"url\":\"string\",\"includeHtml\":true}")

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

	req.Header.Add("Content-Type", "application/json")
	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-capture-url-screenshot")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'
request.body = "{\"url\":\"string\",\"includeHtml\":true}"

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

import requests

url = "https://api.dev.me/v1-capture-url-screenshot"

payload = {
    "url": "string",
    "includeHtml": True
}
headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("POST", url, json=payload, headers=headers)

print(response.text)

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\"url\":\"string\",\"includeHtml\":true}");
Request request = new Request.Builder()
  .url("https://api.dev.me/v1-capture-url-screenshot")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\"url\":\"string\",\"includeHtml\":true}")
val request = Request.Builder()
  .url("https://api.dev.me/v1-capture-url-screenshot")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

import Foundation

let headers = [
  "Content-Type": "application/json",
  "Accept": "application/json",
  "x-api-key": "demo-key"
]
let parameters = [
  "url": "string",
  "includeHtml": true
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-capture-url-screenshot")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-capture-url-screenshot");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
request.AddParameter("application/json", "{\"url\":\"string\",\"includeHtml\":true}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

POST /v1-capture-url-screenshot

Capture a screenshot of a URL

Body parameter

{
  "url": "string",
  "includeHtml": true
}

Parameters

Name	In	Type	Required	Description
body	body	CaptureUrlScreenshotIn	true	none

Example responses

200 Response

{
  "url": "string",
  "screenshot": "string",
  "html": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	response	CaptureUrlScreenshotOut

V1ScrapeUrlData

Code samples

curl --request POST \
  --url https://api.dev.me/v1-scrape-url-data \
  --header 'Accept: application/json' \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: demo-key' \
  --data '{"url":"string"}'


require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.dev.me/v1-scrape-url-data', [
  'body' => '{"url":"string"}',
  'headers' => [
    'Accept' => 'application/json',
    'Content-Type' => 'application/json',
    'x-api-key' => 'demo-key',
  ],
]);

echo $response->getBody();

import axios from "axios";

const options = {
  method: 'POST',
  url: 'https://api.dev.me/v1-scrape-url-data',
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json',
    'x-api-key': 'demo-key'
  },
  data: {url: 'string'}
};

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

package main

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

func main() {

	url := "https://api.dev.me/v1-scrape-url-data"

	payload := strings.NewReader("{\"url\":\"string\"}")

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

	req.Header.Add("Content-Type", "application/json")
	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-scrape-url-data")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request["Accept"] = 'application/json'
request["x-api-key"] = 'demo-key'
request.body = "{\"url\":\"string\"}"

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

import requests

url = "https://api.dev.me/v1-scrape-url-data"

payload = {"url": "string"}
headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "x-api-key": "demo-key"
}

response = requests.request("POST", url, json=payload, headers=headers)

print(response.text)

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\"url\":\"string\"}");
Request request = new Request.Builder()
  .url("https://api.dev.me/v1-scrape-url-data")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build();

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\"url\":\"string\"}")
val request = Request.Builder()
  .url("https://api.dev.me/v1-scrape-url-data")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("x-api-key", "demo-key")
  .build()

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

import Foundation

let headers = [
  "Content-Type": "application/json",
  "Accept": "application/json",
  "x-api-key": "demo-key"
]
let parameters = ["url": "string"] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.dev.me/v1-scrape-url-data")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

library(httr)

url ```

```csharp
var client = new RestClient("https://api.dev.me/v1-scrape-url-data");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Accept", "application/json");
request.AddHeader("x-api-key", "demo-key");
request.AddParameter("application/json", "{\"url\":\"string\"}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

POST /v1-scrape-url-data

Scrape metadata, OpenGraph and Html from a URL

Body parameter

{
  "url": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	ScrapeUrlDataIn	true	none

Example responses

200 Response

{
  "url": "string",
  "metadata": {},
  "openGraph": {}
}

Responses

Status	Meaning	Description	Schema
200	OK	response	ScrapeUrlDataOut

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

CaptureUrlScreenshotIn

{
  "url": "string",
  "includeHtml": true
}

Properties

Name	Type	Required	Restrictions	Description
url	string	false	none	URL to capture
includeHtml	boolean	false	none	Include HTML in the response

CaptureUrlScreenshotOut

{
  "url": "string",
  "screenshot": "string",
  "html": "string"
}

Properties

Name	Type	Required	Restrictions	Description
url	string	false	none	URL to capture
screenshot	string	false	none	Base64 encoded screenshot
html	string	false	none	HTML of the page

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

CreateOnetimeUrlIn

{
  "text": "string",
  "passphrase": "string",
  "lifetime": "string",
  "domain": "string"
}

Properties

Name	Type	Required	Restrictions	Description
text	string	false	none	secret text
passphrase	string	false	none	passphrase
lifetime	string	false	none	lifetime in seconds
domain	string	false	none	custom domain name if allowed by the user

CreateOnetimeUrlOut

{
  "onetimeUrl": "string",
  "sid": "string",
  "createdAt": "string"
}

Properties

Name	Type	Required	Restrictions	Description
onetimeUrl	string	false	none	onetime url
sid	string	false	none	onetime url id
createdAt	string	false	none	created at timestamp

CreateShortUrlIn

{
  "url": "string",
  "domain": "string"
}

Properties

Name	Type	Required	Restrictions	Description
url	string	false	none	long url
domain	string	false	none	domain name

CreateShortUrlOut

{
  "url": "string",
  "shortUrl": "string",
  "sid": "string",
  "createdAt": "string"
}

Properties

Name	Type	Required	Restrictions	Description
url	string	false	none	original url
shortUrl	string	false	none	short url
sid	string	false	none	short url id
createdAt	string	false	none	created at timestamp

DeleteOnetimeUrlIn

{
  "sid": "string",
  "domain": "string",
  "passphrase": "string"
}

Properties

Name	Type	Required	Restrictions	Description
sid	string	false	none	onetime url sid
domain	string	false	none	custom domain name if allowed by the user
passphrase	string	false	none	passphrase

DeleteOnetimeUrlOut

{
  "success": true
}

Properties

Name	Type	Required	Restrictions	Description
success	boolean	false	none	delete success

DeleteShortUrlIn

{
  "sid": "string",
  "domain": "string"
}

Properties

Name	Type	Required	Restrictions	Description
sid	string	false	none	short url sid
domain	string	false	none	domain name for short url

DeleteShortUrlOut

{
  "success": true
}

Properties

Name	Type	Required	Restrictions	Description
success	boolean	false	none	delete success

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

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": {}
}

Properties

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

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",
  "whoisText": "string",
  "whoisJson": {}
}

Properties

Name	Type	Required	Restrictions	Description
domain	string	false	none	Domain name
whoisText	string	false	none	WHOIS text
whoisJson	object	false	none	WHOIS JSON

GetEmailDetailsOut

{
  "email": "string",
  "validMx": true,
  "validSmtp": true,
  "validFormat": true,
  "isDisposable": true,
  "isFree": true,
  "domainAge": 0,
  "score": 0
}

Properties

Name	Type	Required	Restrictions	Description
email	string	false	none	email address
validMx	boolean	false	none	is the domain is valid with dns MX record
validSmtp	boolean	false	none	is email address valid with SMTP Connect and Reply
validFormat	boolean	false	none	is email 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": 0,
  "timeZone": "string",
  "areaCode": "string",
  "region": "string",
  "name": "string"
}

Properties

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

GetIpDetailsOut

{
  "ip": "string",
  "countryCode": "string",
  "registeredCountryCode": "string",
  "asn": "string",
  "aso": "string",
  "city": {
    "accuracyRadius": 0,
    "latitude": 0,
    "longitude": 0,
    "timeZone": "string",
    "areaCode": "string",
    "region": "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

GetOnetimeUrlDetailsOut

{
  "onetimeUrl": "string",
  "sid": "string",
  "text": "string",
  "expireAt": "string",
  "createdAt": "string"
}

Properties

Name	Type	Required	Restrictions	Description
onetimeUrl	string	false	none	onetime url
sid	string	false	none	onetime url sid
text	string	false	none	secret text
expireAt	string	false	none	expire at timestamp
createdAt	string	false	none	created at timestamp

GetPhoneDetailsOut

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

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
isDisposable	boolean	false	none	is phone number disposable

GetShortUrlDetailsOut

{
  "url": "string",
  "shortUrl": "string",
  "sid": "string",
  "domain": "string",
  "createdAt": "string",
  "updatedAt": "string"
}

Properties

Name	Type	Required	Restrictions	Description
url	string	false	none	original url
shortUrl	string	false	none	short url
sid	string	false	none	short url sid
domain	string	false	none	domain name used to create short url
createdAt	string	false	none	created at timestamp
updatedAt	string	false	none	updated at timestamp

GetTextFromImageIn

{
  "image": {},
  "url": "string",
  "lang": "string",
  "psm": "string",
  "outputFormat": "string"
}

Properties

Name	Type	Required	Restrictions	Description
image	object(base64 encoded image)	false	none	image
url	string(Remote Image URL)	false	none	url
lang	string(Language of the text)	false	none	language
psm	string(page segmentation mode)	false	none	page
outputFormat	string(output format of the text (text, pdf))	false	none	outputFormat

GetTextFromImageOut

{
  "text": "string"
}

Properties

Name	Type	Required	Restrictions	Description
text	string	false	none	parsed text from image

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

ScrapeUrlDataIn

{
  "url": "string"
}

Properties

Name	Type	Required	Restrictions	Description
url	string	false	none	URL to scrape

ScrapeUrlDataOut

{
  "url": "string",
  "metadata": {},
  "openGraph": {}
}

Properties

Name	Type	Required	Restrictions	Description
url	string	false	none	URL to scrape
metadata	object	false	none	Scraped data
openGraph	object	false	none	OpenGraph data

UpdateShortUrlIn

{
  "_id": "string",
  "sid": "string",
  "domain": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	short url id to update
sid	string	false	none	short url sid
domain	string	false	none	new domain name for short url

UpdateShortUrlOut

{
  "originalUrl": "string",
  "shortUrl": "string",
  "sid": "string"
}

Properties

Name	Type	Required	Restrictions	Description
originalUrl	string	false	none	original url
shortUrl	string	false	none	short url
sid	string	false	none	short url sid

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