NAV navbar
nicesi
http javascript python php ruby java csharp go swift kotlin

Introduction

Welcome to Nicesi API v1! Our API provides RESTful HTTP access to a large part of the functionality of Nicesi.

Nicesi's API documentation page was inspired by Slate

API Format

API results are currently returned in JSON formats. Specify the JSON format by including the HTTP header in all requests:

Content-type: application/json

REST API Client

We offer a ready to use collection of requests for Insomnia The request file contains all example requests from this documentation.

Insomnia

To explore our APIs with Insomnia, follow these steps:

{
  "API_KEY": "CHANGE-IT-WITH-YOUR-API-KEY"
}

Authentication

There is two way to authenticate against Nicesi.

Token Authentication

X-Rapidapi-Key: YOUR-RAPID-API-KEY
Host: https://currency26.p.rapidapi.com

To authenticate against Nicesi using tokens, you need to pass an YOUR-RAPID-API-KEY via an X-Rapidapi-Key header or rapidapi-key query parameter.

We will update from free plan to paid plan when the payment is completed. BUY NOW

Help

If you have any questions/feedback regarding the Nicesi API v1, please reach out to us. We're here to help. You can email Nicesi Support at hello@nicesi.com.

Errors

The Nicesi API uses the following error codes:

Error Code Meaning
400 Bad Request -- Your request is invalid
401 Unauthorized -- Your API key is incorrect
403 Forbidden -- The resource requested is hidden for administrators only
404 Not Found -- The specified resource could not be found
405 Method Not Allowed -- You tried to access a resource with an invalid method
406 Not Acceptable -- You requested a format that isn't json
429 Too Many Requests -- You're requesting too many resources! Slow down!
500 Internal Server Error -- We had a problem with our server. Try again later.
503 Service Unavailable -- We're temporarily offline for maintenance. Please try again later.

Endpoints

APIs: Currency Exchange Rate API, ...

Location, Email, Language, Account APIs will be published soon.

Exchange API

Latest Rate

GET /rate/EUR/USD HTTP/1.1
HTTP/1.1 200 OK
Content-Type: application/json
var request = require("request");

var options = {
  url: "https://currency26.p.rapidapi.com/rate/ETH/USD?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY",
  json: true
};

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

  var data = body;
});
import requests
import json

url = 'https://currency26.p.rapidapi.com/rate/ETH/USD?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY'

response = requests.get(url)
response.raise_for_status()
response.json()
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => "https://currency26.p.rapidapi.com/rate/ETH/USD?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY",
  CURLOPT_RETURNTRANSFER => true  
));

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  $json_response = json_decode($response);
}
require 'net/http'
require 'json'

uri = URI('https://currency26.p.rapidapi.com/rate/ETH/USD?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY')

response = Net::HTTP.get(uri)
data = JSON.parse(response)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://currency26.p.rapidapi.com/rate/ETH/USD?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY")
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("https://currency26.p.rapidapi.com/rate/ETH/USD?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
package main

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

func main() {
    url := "https://currency26.p.rapidapi.com/rate/ETH/USD?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY"

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

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

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

    fmt.Println(res)
    fmt.Println(string(body))
}
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://currency26.p.rapidapi.com/rate/ETH/USD?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
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()
val client = OkHttpClient()

val request = Request.Builder()
    .url("https://currency26.p.rapidapi.com/rate/ETH/USD?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY")
    .build()

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

The above request returns JSON structured like this:

{
    "ts": 1591894347,
    "rt": 1.135046
}

This endpoint to get latest currency exchange rates (60/30/10 minute updates).

GET rate/{base_currency}/{target_currency}

Convert

GET /convert/EUR/USD/10 HTTP/1.1
HTTP/1.1 200 OK
Content-Type: application/json
var request = require("request");

var options = {
  url: "https://currency26.p.rapidapi.com/convert/EUR/USD/10?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY",
  json: true
};

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

  var data = body;
});
import requests
import json

url = 'https://currency26.p.rapidapi.com/convert/EUR/USD/10?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY'

response = requests.get(url)
response.raise_for_status()
response.json()
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => "https://currency26.p.rapidapi.com/convert/EUR/USD/10?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY",
  CURLOPT_RETURNTRANSFER => true  
));

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  $json_response = json_decode($response);
}
require 'net/http'
require 'json'

uri = URI('https://currency26.p.rapidapi.com/convert/EUR/USD/10?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY')

response = Net::HTTP.get(uri)
data = JSON.parse(response)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://currency26.p.rapidapi.com/convert/EUR/USD/10?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY")
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("https://currency26.p.rapidapi.com/convert/EUR/USD/10?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
package main

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

func main() {
    url := "https://currency26.p.rapidapi.com/convert/EUR/USD/10?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY"

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

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

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

    fmt.Println(res)
    fmt.Println(string(body))
}
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://currency26.p.rapidapi.com/convert/EUR/USD/10?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
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()
val client = OkHttpClient()

val request = Request.Builder()
    .url("https://currency26.p.rapidapi.com/convert/EUR/USD/10?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY")
    .build()

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

The above request returns JSON structured like this:

{
    "ts": 1593249076,
    "vl": 11.192449
}

This endpoint to get converted amount from one currency to another. (5 minute updates).

GET convert/{base_currency}/{target_currency}/{value}

All Latest Rates

GET /rates HTTP/1.1
HTTP/1.1 200 OK
Content-Type: application/json
var request = require("request");

var options = {
  url: "https://currency26.p.rapidapi.com/rates?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY",
  json: true
};

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

  var data = body;
});
import requests
import json

url = 'https://currency26.p.rapidapi.com/rates?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY'

response = requests.get(url)
response.raise_for_status()
response.json()
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => "https://currency26.p.rapidapi.com/rates?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY",
  CURLOPT_RETURNTRANSFER => true  
));

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  $json_response = json_decode($response);
}
require 'net/http'
require 'json'

uri = URI('https://currency26.p.rapidapi.com/rates?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY')

response = Net::HTTP.get(uri)
data = JSON.parse(response)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://currency26.p.rapidapi.com/rates?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY")
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("https://currency26.p.rapidapi.com/rates?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
package main

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

func main() {
    url := "https://currency26.p.rapidapi.com/rates?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY"

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

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

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

    fmt.Println(res)
    fmt.Println(string(body))
}
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://currency26.p.rapidapi.com/rates?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
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()
val client = OkHttpClient()

val request = Request.Builder()
    .url("https://currency26.p.rapidapi.com/rates?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY")
    .build()

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

The above request returns JSON structured like this:

{
    "ts": 1593249076,
    "bs": "USD",
      "rt": {
        "ETH": 0.004352,
        "EUR": 0.89346,
        "GBP": 0.813649,
        "JPY": 107.18,
        "...": ...
      }
}

This endpoint to get latest all currency exchange rates based USD (60/30/10 minute updates).

GET rates

List of Currencies

GET /list HTTP/1.1
HTTP/1.1 200 OK
Content-Type: application/json
var request = require("request");

var options = {
  url: "https://currency26.p.rapidapi.com/list?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY",
  json: true
};

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

  var data = body;
});
import requests
import json

url = 'https://currency26.p.rapidapi.com/list?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY'

response = requests.get(url)
response.raise_for_status()
response.json()
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => "https://currency26.p.rapidapi.com/list?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY",
  CURLOPT_RETURNTRANSFER => true  
));

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  $json_response = json_decode($response);
}
require 'net/http'
require 'json'

uri = URI('https://currency26.p.rapidapi.com/list?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY')

response = Net::HTTP.get(uri)
data = JSON.parse(response)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://currency26.p.rapidapi.com/list?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY")
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("https://currency26.p.rapidapi.com/list?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
package main

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

func main() {
    url := "https://currency26.p.rapidapi.com/list?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY"

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

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

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

    fmt.Println(res)
    fmt.Println(string(body))
}
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://currency26.p.rapidapi.com/list?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
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()
val client = OkHttpClient()

val request = Request.Builder()
    .url("https://currency26.p.rapidapi.com/list?rapidapi-key=CHANGE-IT-WITH-YOUR-API-KEY")
    .build()

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

The above request returns JSON structured like this:

{
    "AED": "United Arab Emirates Dirham",
    "AFN": "Afghan Afghani",
    "ALL": "Albanian Lek",
    "AMD": "Armenian Dram",
    "ANG": "Netherlands Antillean Gulden",
    "AOA": "Angolan Kwanza",
    "ARS": "Argentine Peso",
    "AUD": "Australian Dollar",
    "AWG": "Aruban Florin",
    "AZN": "Azerbaijani Manat",
    "BAM": "Bosnia and Herzegovina Convertible Mark",
    "BBD": "Barbadian Dollar",
    "BDT": "Bangladeshi Taka",
    "BGN": "Bulgarian Lev",
    "BHD": "Bahraini Dinar",
    "BIF": "Burundian Franc",
    "BMD": "Bermudian Dollar",
    "BND": "Brunei Dollar",
    "BOB": "Bolivian Boliviano",
    "BRL": "Brazilian Real",
    "BSD": "Bahamian Dollar",
    "BTN": "Bhutanese Ngultrum",
    "BWP": "Botswana Pula",
    "BYN": "Belarusian Ruble",
    "BYR": "Belarusian Ruble",
    "BZD": "Belize Dollar",
    "CAD": "Canadian Dollar",
    "CDF": "Congolese Franc",
    "CHF": "Swiss Franc",
    "CLF": "Unidad de Fomento",
    "CLP": "Chilean Peso",
    "CNH": "Chinese Renminbi Yuan Offshore",
    "CNY": "Chinese Renminbi Yuan",
    "COP": "Colombian Peso",
    "CRC": "Costa Rican Colón",
    "CUC": "Cuban Convertible Peso",
    "CVE": "Cape Verdean Escudo",
    "CZK": "Czech Koruna",
    "DJF": "Djiboutian Franc",
    "DKK": "Danish Krone",
    "DOP": "Dominican Peso",
    "DZD": "Algerian Dinar",
    "EEK": "Estonian Kroon",
    "EGP": "Egyptian Pound",
    "ERN": "Eritrean Nakfa",
    "ETB": "Ethiopian Birr",
    "EUR": "Euro",
    "FJD": "Fijian Dollar",
    "FKP": "Falkland Pound",
    "GBP": "British Pound",
    "GEL": "Georgian Lari",
    "GGP": "Guernsey Pound",
    "GHS": "Ghanaian Cedi",
    "GIP": "Gibraltar Pound",
    "GMD": "Gambian Dalasi",
    "GNF": "Guinean Franc",
    "GTQ": "Guatemalan Quetzal",
    "GYD": "Guyanese Dollar",
    "HKD": "Hong Kong Dollar",
    "HNL": "Honduran Lempira",
    "HRK": "Croatian Kuna",
    "HTG": "Haitian Gourde",
    "HUF": "Hungarian Forint",
    "IDR": "Indonesian Rupiah",
    "ILS": "Israeli New Sheqel",
    "IMP": "Isle of Man Pound",
    "INR": "Indian Rupee",
    "IQD": "Iraqi Dinar",
    "ISK": "Icelandic Króna",
    "JEP": "Jersey Pound",
    "JMD": "Jamaican Dollar",
    "JOD": "Jordanian Dinar",
    "JPY": "Japanese Yen",
    "KES": "Kenyan Shilling",
    "KGS": "Kyrgyzstani Som",
    "KHR": "Cambodian Riel",
    "KMF": "Comorian Franc",
    "KRW": "South Korean Won",
    "KWD": "Kuwaiti Dinar",
    "KYD": "Cayman Islands Dollar",
    "KZT": "Kazakhstani Tenge",
    "LAK": "Lao Kip",
    "LBP": "Lebanese Pound",
    "LKR": "Sri Lankan Rupee",
    "LRD": "Liberian Dollar",
    "LSL": "Lesotho Loti",
    "LTL": "Lithuanian Litas",
    "LVL": "Latvian Lats",
    "LYD": "Libyan Dinar",
    "MAD": "Moroccan Dirham",
    "MDL": "Moldovan Leu",
    "MGA": "Malagasy Ariary",
    "MKD": "Macedonian Denar",
    "MMK": "Myanmar Kyat",
    "MNT": "Mongolian Tögrög",
    "MOP": "Macanese Pataca",
    "MRO": "Mauritanian Ouguiya",
    "MTL": "Maltese Lira",
    "MUR": "Mauritian Rupee",
    "MVR": "Maldivian Rufiyaa",
    "MWK": "Malawian Kwacha",
    "MXN": "Mexican Peso",
    "MYR": "Malaysian Ringgit",
    "MZN": "Mozambican Metical",
    "NAD": "Namibian Dollar",
    "NGN": "Nigerian Naira",
    "NIO": "Nicaraguan Córdoba",
    "NOK": "Norwegian Krone",
    "NPR": "Nepalese Rupee",
    "NZD": "New Zealand Dollar",
    "OMR": "Omani Rial",
    "PAB": "Panamanian Balboa",
    "PEN": "Peruvian Sol",
    "PGK": "Papua New Guinean Kina",
    "PHP": "Philippine Peso",
    "PKR": "Pakistani Rupee",
    "PLN": "Polish Złoty",
    "PYG": "Paraguayan Guaraní",
    "QAR": "Qatari Riyal",
    "RON": "Romanian Leu",
    "RSD": "Serbian Dinar",
    "RUB": "Russian Ruble",
    "RWF": "Rwandan Franc",
    "SAR": "Saudi Riyal",
    "SBD": "Solomon Islands Dollar",
    "SCR": "Seychellois Rupee",
    "SEK": "Swedish Krona",
    "SGD": "Singapore Dollar",
    "SHP": "Saint Helenian Pound",
    "SLL": "Sierra Leonean Leone",
    "SOS": "Somali Shilling",
    "SRD": "Surinamese Dollar",
    "SSP": "South Sudanese Pound",
    "STD": "São Tomé and Príncipe Dobra",
    "SVC": "Salvadoran Colón",
    "SZL": "Swazi Lilangeni",
    "THB": "Thai Baht",
    "TJS": "Tajikistani Somoni",
    "TMT": "Turkmenistani Manat",
    "TND": "Tunisian Dinar",
    "TOP": "Tongan Paʻanga",
    "TRY": "Turkish Lira",
    "TTD": "Trinidad and Tobago Dollar",
    "TWD": "New Taiwan Dollar",
    "TZS": "Tanzanian Shilling",
    "UAH": "Ukrainian Hryvnia",
    "UGX": "Ugandan Shilling",
    "USD": "US Dollar",
    "UYU": "Uruguayan Peso",
    "UZS": "Uzbekistan Som",
    "VEF": "Venezuelan Bolívar",
    "VES": "Venezuelan Bolívar Soberano",
    "VND": "Vietnamese Đồng",
    "VUV": "Vanuatu Vatu",
    "WST": "Samoan Tala",
    "XAF": "Central African Cfa Franc",
    "XAG": "Silver (Troy Ounce)",
    "XAU": "Gold (Troy Ounce)",
    "XCD": "East Caribbean Dollar",
    "XDR": "Special Drawing Rights",
    "XOF": "West African Cfa Franc",
    "XPD": "Palladium",
    "XPF": "Cfp Franc",
    "XPT": "Platinum",
    "YER": "Yemeni Rial",
    "ZAR": "South African Rand",
    "ZMK": "Zambian Kwacha",
    "ZMW": "Zambian Kwacha",
    "ZWL": "Zimbabwean Dollar",
    "ATOM": "Cosmos",
    "BAT": "Basic Attention Token",
    "BCH": "Bitcoin Cash",
    "BSV": "Bitcoin SV",
    "BTC": "Bitcoin",
    "DAI": "DAI",
    "DASH": "DASH",
    "EOS": "EOS",
    "ETC": "Ethereum Classic",
    "ETH": "Ethereum",
    "KNC": "Kyber Network",
    "LINK": "Chainlink",
    "LTC": "Litecoin",
    "OMG": "OMG Network",
    "OXT": "Orchid Token",
    "REP": "Augur",
    "USDC": "USD Coin",
    "XLM": "Stellar",
    "XRP": "XRP",
    "XTZ": "Tezos",
    "ZEC": "Zcash",
    "ZRX": "0x"
}

This endpoint to get list of currencies.

GET list

Changelog

v1.0