RemitRadar API

Main directory API endpoints:

Method's name	Description	Changing
GetCompanies	Returns list of all companies	Every day
GetCountries	Returns list of all countries	Never
GetCurrencies	Returns list of all currencies	Never
GetDeliveryTypes	Returns list of all delivery types	Sometimes

Company details and specs API endpoints:

Method's name	Description	Changing
GetCompanyCorridors	Returns list of all company's supported corridors	Every day
GetCompanyCorridor	Returns detailed data for the defined company and corridor	Every day
GetCorridorDetails	Returns detailed data for the defined direction	Every day

Remittance pricing API endpoints:

Method's name	Description	Changing
GetCompanyQuote	Returns single quote / pricing for the desired company	Every second
GetQuotes	Returns all quotes for the selected corridor	Every second
GetAllQuotes	Returns all quotes for the selected corridor with all combination	Every second

FX Mid Market API endpoints:

Method's name	Description	Changing
GetMarketRate	Returns current exchange market rate	Every second
GetHistoricalMarketRates	Returns list of all exchange market rates during specified period	Every second

GET Companies

Returns list of all companies

https://api.remitradar.com/GetCompanies

Code samples

                                        
curl -X GET \
  https://api.remitradar.com/GetCompanies \
  -H 'accept: application/json' \
  -H 'x-api-key:Your_Secret_Key'

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
  .url("https://api.remitradar.com/GetCompanies")
  .get()
  .addHeader("accept", "application/json")
  .addHeader("x-api-key", "Your_Secret_Key")
  .build();
Response response = client.newCall(request).execute();

package main
import (
	"fmt"
	"net/http"
	"io/ioutil"
)
func main() {
	url := "https://api.remitradar.com/GetCompanies"
	req, _ := http.NewRequest("GET", url, nil)
	req.Header.Add("accept", "application/json")
	req.Header.Add("x-api-key", "Your_Secret_Key")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)
	fmt.Println(res)
	fmt.Println(string(body))
}

GET /GetCompanies HTTP/1.1
Host: api.remitradar.com
Accept: application/json
x-api-key:Your_Secret_Key
Cache-Control: no-cache

var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
  if (this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.remitradar.com/GetCompanies");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("x-api-key", "Your_Secret_Key");
xhr.send(data);

                                        
var client = new RestClient("https://api.remitradar.com/GetCompanies");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "Your_Secret_Key");
request.AddHeader("accept", "application/json");
IRestResponse response = client.Execute(request);

setUrl('https://api.remitradar.com/GetCompanies');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders(array(
  'x-api-key' => 'Your_Secret_Key',
  'accept' => 'application/json'
));
try {
  $response = $request->send();
  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
?>

var request = require("request");
var options = { method: 'GET',
  url: 'https://api.remitradar.com/GetCompanies',
  headers: { 'x-api-key': 'Your_Secret_Key', accept: 'application/json' } 
};
request(options, function (error, response, body) {
  if (error) throw new Error(error);
  console.log(body);
});

import requests
url = "https://api.remitradar.com/GetCompanies"
headers = {
    'accept': "application/json",
    'x-api-key': "Your_Secret_Key"
    }
response = requests.request("GET", url, headers=headers)
print(response.text)

Success-Response:

{
  {
    "Status":"Success",
    "Message":"",
    "Data":[ 
        {
            "ID": 20693, 
            "Name": "ArcaPay", 
            "NameLowerNoSpace": "arcapay", 
            "Description": "ArcaPay is...",
            "Logo": "https://remitradar.com/assets/partnerImages/arcapay.png", 
            "IsActive": true
        }
        ,
        {
            "ID": 6, 
            "Name": "Azimo", 
            "NameLowerNoSpace": "azimo", 
            "Description": "Money transfers...",
            "Logo": "https://remitradar.com/assets/partnerImages/azimo.png", 
            "IsActive": true
        }
    ]
}
}

GET Countries

Returns list of all countries

https://api.remitradar.com/GetCountries

Code samples

                                        
curl -X GET \
  https://api.remitradar.com/GetCountries \
  -H 'accept: application/json' \
  -H 'x-api-key:Your_Secret_Key'

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
  .url("https://api.remitradar.com/GetCountries")
  .get()
  .addHeader("accept", "application/json")
  .addHeader("x-api-key", "Your_Secret_Key")
  .build();
Response response = client.newCall(request).execute();

package main
import (
	"fmt"
	"net/http"
	"io/ioutil"
)
func main() {
	url := "https://api.remitradar.com/GetCountries"
	req, _ := http.NewRequest("GET", url, nil)
	req.Header.Add("accept", "application/json")
	req.Header.Add("x-api-key", "Your_Secret_Key")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)
	fmt.Println(res)
	fmt.Println(string(body))
}

GET /GetCountries HTTP/1.1
Host: api.remitradar.com
Accept: application/json
x-api-key:Your_Secret_Key
Cache-Control: no-cache

var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
  if (this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.remitradar.com/GetCountries");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("x-api-key", "Your_Secret_Key");
xhr.send(data);

                                        
var client = new RestClient("https://api.remitradar.com/GetCountries");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "Your_Secret_Key");
request.AddHeader("accept", "application/json");
IRestResponse response = client.Execute(request);

setUrl('https://api.remitradar.com/GetCountries');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders(array(
  'x-api-key' => 'Your_Secret_Key',
  'accept' => 'application/json'
));
try {
  $response = $request->send();
  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
} ?>

var request = require("request");
var options = { method: 'GET',
  url: 'https://api.remitradar.com/GetCountries',
  headers: { 'x-api-key': 'Your_Secret_Key', accept: 'application/json' } 
};
request(options, function (error, response, body) {
  if (error) throw new Error(error);
  console.log(body);
});

import requests
url = "https://api.remitradar.com/GetCountries"
headers = {
    'accept': "application/json",
    'x-api-key': "Your_Secret_Key"
    }
response = requests.request("GET", url, headers=headers)
print(response.text)

Success-Response:

{
  {
    "Status":"Success",
    "Message":"",
    "Data":[ 
        {
            "Code":"AB",
            "Name":"Abkhazia"
        }
        ,
        {
            "Code":"AD",
            "Name":"Andorra"
        }
        ,
        {
            "Code":"AE",
            "Name":"UAE"
        }
        ,
        {
            "Code":"AF",
            "Name":"Afghanistan"
        }
    ]
}
}

GET Currencies

Returns list of all currencies

https://api.remitradar.com/GetCurrencies

Code samples

                                        
curl -X GET \
  https://api.remitradar.com/GetCurrencies \
  -H 'accept: application/json' \
  -H 'x-api-key:Your_Secret_Key'

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
  .url("https://api.remitradar.com/GetCurrencies")
  .get()
  .addHeader("accept", "application/json")
  .addHeader("x-api-key", "Your_Secret_Key")
  .build();
Response response = client.newCall(request).execute();

package main
import (
	"fmt"
	"net/http"
	"io/ioutil"
)
func main() {
	url := "https://api.remitradar.com/GetCurrencies"
	req, _ := http.NewRequest("GET", url, nil)
	req.Header.Add("accept", "application/json")
	req.Header.Add("x-api-key", "Your_Secret_Key")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)
	fmt.Println(res)
	fmt.Println(string(body))
}

GET /GetCurrencies HTTP/1.1
Host: api.remitradar.com
Accept: application/json
x-api-key:Your_Secret_Key
Cache-Control: no-cache

var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
  if (this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.remitradar.com/GetCurrencies");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("x-api-key", "Your_Secret_Key");
xhr.send(data);

                                        
var client = new RestClient("https://api.remitradar.com/GetCurrencies");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "Your_Secret_Key");
request.AddHeader("accept", "application/json");
IRestResponse response = client.Execute(request);

setUrl('https://api.remitradar.com/GetCurrencies');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders(array(
  'x-api-key' => 'Your_Secret_Key',
  'accept' => 'application/json'
));
try {
  $response = $request->send();
  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
} ?>

var request = require("request");
var options = { method: 'GET',
  url: 'https://api.remitradar.com/GetCurrencies',
  headers: { 'x-api-key': 'Your_Secret_Key', accept: 'application/json' } 
};
request(options, function (error, response, body) {
  if (error) throw new Error(error);
  console.log(body);
});

import requests
url = "https://api.remitradar.com/GetCurrencies"
headers = {
    'accept': "application/json",
    'x-api-key': "Your_Secret_Key"
    }
response = requests.request("GET", url, headers=headers)
print(response.text)

Success-Response:

{
  {
    "Status":"Success",
    "Message":"",
    "Data":[ 
        {
            "Code":"ADP",
            "Name":"Andorran Peseta"
        }
        ,
        {
            "Code":"AED",
            "Name":"United Arab Emirates Dirham"
        }
        ,
        {
            "Code":"AFA",
            "Name":"Afghanistan Afghani"
        }
    ]
}
}

GET DeliveryTypes

Returns list of all delivery types

https://api.remitradar.com/GetDeliveryTypes

Code samples

                                        
curl -X GET \
  https://api.remitradar.com/GetDeliveryTypes \
  -H 'accept: application/json' \
  -H 'x-api-key:Your_Secret_Key'

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
  .url("https://api.remitradar.com/GetDeliveryTypes")
  .get()
  .addHeader("accept", "application/json")
  .addHeader("x-api-key", "Your_Secret_Key")
  .build();
Response response = client.newCall(request).execute();

package main
import (
	"fmt"
	"net/http"
	"io/ioutil"
)
func main() {
	url := "https://api.remitradar.com/GetDeliveryTypes"
	req, _ := http.NewRequest("GET", url, nil)
	req.Header.Add("accept", "application/json")
	req.Header.Add("x-api-key", "Your_Secret_Key")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)
	fmt.Println(res)
	fmt.Println(string(body))
}

GET /GetDeliveryTypes HTTP/1.1
Host: api.remitradar.com
Accept: application/json
x-api-key:Your_Secret_Key
Cache-Control: no-cache

var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
  if (this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.remitradar.com/GetDeliveryTypes");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("x-api-key", "Your_Secret_Key");
xhr.send(data);

                                        
var client = new RestClient("https://api.remitradar.com/GetDeliveryTypes");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "Your_Secret_Key");
request.AddHeader("accept", "application/json");
IRestResponse response = client.Execute(request);

setUrl('https://api.remitradar.com/GetDeliveryTypes');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders(array(
  'x-api-key' => 'Your_Secret_Key',
  'accept' => 'application/json'
));
try {
  $response = $request->send();
  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
} ?>

var request = require("request");
var options = { method: 'GET',
  url: 'https://api.remitradar.com/GetDeliveryTypes',
  headers: { 'x-api-key': 'Your_Secret_Key', accept: 'application/json' } 
};
request(options, function (error, response, body) {
  if (error) throw new Error(error);
  console.log(body);
});

import requests
url = "https://api.remitradar.com/GetDeliveryTypes"
headers = {
    'accept': "application/json",
    'x-api-key': "Your_Secret_Key"
    }
response = requests.request("GET", url, headers=headers)
print(response.text)

Success-Response:

{
  {
    "Status":"Success",
    "Message":"",
    "Data":[ 
        {
            "Code":"ACH_Transfer",
            "Name":"ACH Transfer"
        }
        ,
        {
            "Code":"ACSS_Transfer",
            "Name":"ACSS Transfer"
        }
        ,
        {
            "Code":"BANK_DEPOSIT",
            "Name":"BANK DEPOSIT"
        }
    ]
}
}

GET CompanyCorridors

Returns list of all company's supported corridors

https://api.remitradar.com/GetCompanyCorridors?CompanyId={CompanyId}

Parametrs

Field	Type	Description	Required
CompanyId	Number	Companies unique ID	Yes

Code samples

curl -X GET \
  'https://api.remitradar.com/GetCompanyCorridors?CompanyId={CompanyId}' \
  -H 'accept: application/json' \
  -H 'x-api-key:Your_Secret_Key'

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
  .url("https://api.remitradar.com/GetCompanyCorridors?CompanyId={CompanyId}")
  .get()
  .addHeader("accept", "application/json")
  .addHeader("x-api-key", "Your_Secret_Key")
  .build();
Response response = client.newCall(request).execute();

package main
import (
	"fmt"
	"net/http"
	"io/ioutil"
)
func main() {
	url := "https://api.remitradar.com/GetCompanyCorridors?CompanyId={CompanyId}"
	req, _ := http.NewRequest("GET", url, nil)
	req.Header.Add("accept", "application/json")
	req.Header.Add("x-api-key", "Your_Secret_Key")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)
	fmt.Println(res)
	fmt.Println(string(body))
}

GET /GetCompanyCorridors?CompanyId={CompanyId} HTTP/1.1
Host: api.remitradar.com
Accept: application/json
x-api-key:Your_Secret_Key

var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
  if (this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.remitradar.com/GetCompanyCorridors?CompanyId={CompanyId}");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("x-api-key", "Your_Secret_Key");
xhr.send(data);

var client = new RestClient("https://api.remitradar.com/GetCompanyCorridors?CompanyId={CompanyId}");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "Your_Secret_Key");
request.AddHeader("accept", "application/json");
IRestResponse response = client.Execute(request);

setUrl('https://api.remitradar.com/GetCompanyCorridors');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData(array(
  'CompanyId' => '{CompanyId}'                                           
));
$request->setHeaders(array(
  'x-api-key' => 'Your_Secret_Key',
  'accept' => 'application/json'
));
try {
  $response = $request->send();
  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
} ?>

var request = require("request");
var options = { method: 'GET',
  url: 'https://api.remitradar.com/GetCompanyCorridors',
  qs: { CompanyId: '{CompanyId}' },
  headers: 
   { 'x-api-key': 'Your_Secret_Key',
     accept: 'application/json' } };
request(options, function (error, response, body) {
  if (error) throw new Error(error);
  console.log(body);
});

import requests
url = "https://api.remitradar.com/GetCompanyCorridors"
querystring = {"CompanyId":"{CompanyId}"}
headers = {
    'accept': "application/json",
    'x-api-key': "Your_Secret_Key"
    }
response = requests.request("GET", url, headers=headers, params=querystring)
print(response.text)

Success-Response:

{
    "Status":"Success",
    "Message":"",
    "Data":[ {
        "CountryFrom":"DE",
        "CountryTo":"PH"
    }
    ,
    {
        "CountryFrom":"GB",
        "CountryTo":"PH"
    }
    ,
    {
        "CountryFrom":"US",
        "CountryTo":"IN"
    }
    ]
}

Error-Response:

{
    "Status": "Error", 
    "Message": "'CompanyId' is not valid!", 
    "Data": null
}

GET CompanyCorridor

Returns detailed data for the defined company and corridor

https://api.remitradar.com/GetCompanyCorridor?CompanyId={CompanyId}&CountryFrom={CountryFrom}&CountryTo={CountryTo}

Parametrs

Field	Type	Description	Required
CompanyId	Number	Companies unique ID	Yes
CountryFrom	String	Code of sender country	Yes
CountryTo	String	Code of recipient country	Yes

Code samples

curl -X GET \
  'https://api.remitradar.com/GetCompanyCorridor?CompanyId={CompanyId}&CountryFrom={CountryFrom}&CountryTo={CountryTo}' \
  -H 'accept: application/json' \
  -H 'x-api-key:Your_Secret_Key'

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
  .url("https://api.remitradar.com/GetCompanyCorridor?CompanyId={CompanyId}&CountryFrom={CountryFrom}&CountryTo={CountryTo}")
  .get()
  .addHeader("accept", "application/json")
  .addHeader("x-api-key", "Your_Secret_Key")
  .build();
Response response = client.newCall(request).execute();

package main
import (
	"fmt"
	"net/http"
	"io/ioutil"
)
func main() {
	url := "https://api.remitradar.com/GetCompanyCorridor?CompanyId={CompanyId}&CountryFrom={CountryFrom}&CountryTo={CountryTo}"
	req, _ := http.NewRequest("GET", url, nil)
	req.Header.Add("accept", "application/json")
	req.Header.Add("x-api-key", "Your_Secret_Key")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)
	fmt.Println(res)
	fmt.Println(string(body))
}

GET /GetCompanyCorridor?CompanyId={CompanyId}&CountryFrom={CountryFrom}&CountryTo={CountryTo} HTTP/1.1
Host: api.remitradar.com
Accept: application/json
x-api-key:Your_Secret_Key

var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
  if (this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.remitradar.com/GetCompanyCorridor?CompanyId={CompanyId}&CountryFrom={countryFrom}&CountryTo={countryTo}");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("x-api-key", "Your_Secret_Key");
xhr.send(data);

var client = new RestClient("https://api.remitradar.com/GetCompanyCorridor?CompanyId={CompanyId}&CountryFrom={countryFrom}&CountryTo={countryTo}");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "Your_Secret_Key");
request.AddHeader("accept", "application/json");
IRestResponse response = client.Execute(request);

setUrl('https://api.remitradar.com/GetCompanyCorridor');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData(array(
  'CompanyId' => '{CompanyId}',
  'CountryFrom' => '{CountryFrom}',
  'CountryTo' => {CountryTo}                                              
));
$request->setHeaders(array(
  'x-api-key' => 'Your_Secret_Key',
  'accept' => 'application/json'
));
try {
  $response = $request->send();
  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
} ?>

var request = require("request");
var options = { method: 'GET',
  url: 'https://api.remitradar.com/GetCompanyCorridor',
  qs: { CompanyId: '{CompanyId}', CountryTo : '{CountryTo}' , CountryFrom : '{CountryFrom}' },
  headers: 
   { 'x-api-key': 'Your_Secret_Key',
     accept: 'application/json' } };
request(options, function (error, response, body) {
  if (error) throw new Error(error);
  console.log(body);
});

import requests
url = "https://api.remitradar.com/GetCompanyCorridor"
querystring = {"CompanyId":"{CompanyId}" , "CountryFrom":"{CountryFrom}", "CountryTo" : "{CountryTo}"}
headers = {
    'accept': "application/json",
    'x-api-key': "Your_Secret_Key"
    }
response = requests.request("GET", url, headers=headers, params=querystring)
print(response.text)

Success-Response:

{
    "Status":"Success",
    "Message":"",
    "Data":[ {
        "CountryFrom":"DE",
        "CountryTo":"PH",
        "Companies":[ {
            "ID":9,
            "Name":"Kabayan Remit",
            "NameLowerNoSpace":"kabayanremit",
            "CurrenciesFrom":[ {
                "Code":"EUR",
                "DeliveryMethods":[ {
                    "DeliveryType": "BANK_DEPOSIT", 
                    "MinAmount": "", 
                    "MaxAmount": "", 
                    "DeliveryTime": "0-1 working days"
                }
                ,
                {
                    "DeliveryType": "DEBIT_CARD", 
                    "MinAmount": "", 
                    "MaxAmount": "", 
                    "DeliveryTime": "Instant"
                }
                ]
            }
            ],
            "CurrenciesTo":[ {
                "Code":"PHP",
                "DeliveryMethods":[ {
                    "DeliveryType": "BANK_DEPOSIT", "MinAmount": "", 
                    "MaxAmount": "", 
                    "DeliveryTime": "0-1 working days"
                }
                ,
                {
                    "DeliveryType": "CASH_PICK_UP", "MinAmount": "", 
                    "MaxAmount": "", 
                    "DeliveryTime": "0-1 working days"
                }
                ,
                {
                    "DeliveryType": "PHYSICAL_DELIVERY", "MinAmount": "", 
                    "MaxAmount": "", 
                    "DeliveryTime": "0-5 working days"
                }
                ]
            }
            ]
        }
        ]
    }
    ,
    {
        "CountryFrom":"GB",
        "CountryTo":"PH",
        "Companies":[ {
            "ID":9,
            "Name":"Kabayan Remit",
            "NameLowerNoSpace":"kabayanremit",
            "CurrenciesFrom":[ {
                "Code":"GBP",
                "DeliveryMethods":[ {
                    "DeliveryType": "BANK_DEPOSIT", 
                    "MinAmount": "", 
                    "MaxAmount": "", 
                    "DeliveryTime": "0-1 working days"
                }
                ,
                {
                    "DeliveryType": "DEBIT_CARD", 
                    "MinAmount": "", 
                    "MaxAmount": "", 
                    "DeliveryTime": "Instant"
                }
                ]
            }
            ],
            "CurrenciesTo":[ {
                "Code":"PHP",
                "DeliveryMethods":[ {
                    "DeliveryType": "BANK_DEPOSIT", 
                    "MinAmount": "", 
                    "MaxAmount": "", 
                    "DeliveryTime": "0-1 working days"
                }
                ,
                {
                    "DeliveryType": "CASH_PICK_UP", 
                    "MinAmount": "", 
                    "MaxAmount": "", 
                    "DeliveryTime": "0-1 working days"
                }
                ,
                {
                    "DeliveryType": "PHYSICAL_DELIVERY", 
                    "MinAmount": "", 
                    "MaxAmount": "", 
                    "DeliveryTime": "0-5 working days"
                }
                ]
            }
            ]
        }
        ]
    }
    ]
}

Error-Response:

{
    "Status": "Error", 
    "Message": "'CompanyId' is not valid!", 
    "Data": null
}

GET CorridorDetails

Returns detailed data for the defined direction

https://api.remitradar.com/GetCorridorDetails?CountryFrom={CountryFrom}&CountryTo={CountryTo}

Parametrs

Field	Type	Description	Required
CountryFrom	String	Code of sender country	Yes
CountryTo	String	Code of recipient country	Yes

Code samples

curl -X GET \
  'https://api.remitradar.com/GetCorridorDetails?CountryFrom={CountryFrom}&CountryTo={CountryTo}' \
  -H 'accept: application/json' \
  -H 'x-api-key:Your_Secret_Key'

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
  .url("https://api.remitradar.com/GetCorridorDetails?CountryFrom={CountryFrom}&CountryTo={CountryTo}")
  .get()
  .addHeader("accept", "application/json")
  .addHeader("x-api-key", "Your_Secret_Key")
  .build();
Response response = client.newCall(request).execute();

package main
import (
	"fmt"
	"net/http"
	"io/ioutil"
)
func main() {
	url := "https://api.remitradar.com/GetCorridorDetails?CountryFrom={CountryFrom}&CountryTo={CountryTo}"
	req, _ := http.NewRequest("GET", url, nil)
	req.Header.Add("accept", "application/json")
	req.Header.Add("x-api-key", "Your_Secret_Key")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)
	fmt.Println(res)
	fmt.Println(string(body))
}

GET /GetCorridorDetails?CountryFrom={CountryFrom}&CountryTo={CountryTo} HTTP/1.1
Host: api.remitradar.com
Accept: application/json
x-api-key:Your_Secret_Key

var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
  if (this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.remitradar.com/GetCorridorDetails?CountryFrom={CountryFrom}&CountryTo={CountryTo}");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("x-api-key", "Your_Secret_Key");
xhr.send(data);

var client = new RestClient("https://api.remitradar.com/GetCorridorDetails?CountryFrom={CountryFrom}&CountryTo={CountryTo}");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "Your_Secret_Key");
request.AddHeader("accept", "application/json");
IRestResponse response = client.Execute(request);

setUrl('https://api.remitradar.com/GetCorridorDetails');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData(array(
  'CountryFrom' => '{CountryFrom}',
  'CountryTo' => '{CountryTo}'
));
$request->setHeaders(array(
  'x-api-key' => 'Your_Secret_Key',
  'accept' => 'application/json'
));
try {
  $response = $request->send();
  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
} ?>

var request = require("request");
var options = { method: 'GET',
  url: 'https://api.remitradar.com/GetCorridorDetails',
  qs: { CountryFrom: '{CountryFrom}', CountryTo: '{CountryTo}' },
  headers: 
   { 'x-api-key': 'Your_Secret_Key',
     accept: 'application/json' } };
request(options, function (error, response, body) {
  if (error) throw new Error(error);
  console.log(body);
});

import requests
url = "https://api.remitradar.com/GetCorridorDetails"
querystring = {"CountryFrom":"{CountryFrom}", "CountryTo":"{CountryTo}"}
headers = {
    'accept': "application/json",
    'x-api-key': "Your_Secret_Key"
    }
response = requests.request("GET", url, headers=headers, params=querystring)
print(response.text)

Success-Response:

{
    "Status":"Success",
    "Message":"",
    "Data": {
        "CountryFrom":"IN",
        "CountryTo":"MR",
        "Companies":[
        {
            "ID":28,
            "Name":"MoneyGram",
            "NameLowerNoSpace":"moneygram",
            "CurrenciesFrom":[ {
                "Code":"INR",
                "DeliveryMethods":[ {
                    "DeliveryType": "CASH_PICK_UP", 
                    "MinAmount": "1 USD or equivalent", 
                    "MaxAmount": "10000 USD or equivalent", 
                    "DeliveryTime": "Instant"
                }
                ]
            }
            ],
            "CurrenciesTo":[ {
                "Code":"MRO",
                "DeliveryMethods":[ {
                    "DeliveryType": "CASH_PICK_UP", 
                    "MinAmount": "", 
                    "MaxAmount": "", 
                    "DeliveryTime": "Instant"
                }
                ]
            }
            ]
        }        
        ,
        {
            "ID":3,
            "Name":"Xendpay",
            "NameLowerNoSpace":"xendpay",
            "CurrenciesFrom":[ {
                "Code":"GBP",
                "DeliveryMethods":[ {
                    "DeliveryType": "BANK_DEPOSIT", 
                    "MinAmount": "1 GBP or equivalent", 
                    "MaxAmount": "100000 GBP or equivalent", 
                    "DeliveryTime": "0-2 working days"
                }
                ,
                {
                    "DeliveryType": "DEBIT_CARD", 
                    "MinAmount": "1 GBP or equivalent", 
                    "MaxAmount": "100000 GBP or equivalent", 
                    "DeliveryTime": "Instant"
                }
                ,
                {
                    "DeliveryType": "CREDIT_CARD", 
                    "MinAmount": "1 GBP or equivalent", 
                    "MaxAmount": "100000 GBP or equivalent", 
                    "DeliveryTime": "Instant"
                }
                ]
            }
            ,
            {
                "Code":"USD",
                "DeliveryMethods":[ {
                    "DeliveryType": "BANK_DEPOSIT", 
                    "MinAmount": "1 GBP or equivalent", 
                    "MaxAmount": "100000 GBP or equivalent", 
                    "DeliveryTime": "0-2 working days"
                }
                ,
                {
                    "DeliveryType": "DEBIT_CARD", 
                    "MinAmount": "1 GBP or equivalent", 
                    "MaxAmount": "100000 GBP or equivalent", 
                    "DeliveryTime": "Instant"
                }
                ,
                {
                    "DeliveryType": "CREDIT_CARD", 
                    "MinAmount": "1 GBP or equivalent", 
                    "MaxAmount": "100000 GBP or equivalent", 
                    "DeliveryTime": "Instant"
                }
                ]
            }
            ],
            "CurrenciesTo":[ {
                "Code":"USD",
                "DeliveryMethods":[ {
                    "DeliveryType": "BANK_DEPOSIT", 
                    "MinAmount": "", 
                    "MaxAmount": "", 
                    "DeliveryTime": "0-3 working days"
                }
                ]
            }
            ]
        }
        ]
    }
}

Error-Response:

{
    "Status": "Error", 
    "Message": "'CountryFrom' is not valid!", 
    "Data": null
}

GET CompanyQuote

Returns single quote / pricing for the desired company

https://api.remitradar.com/GetCompanyQuote?CompanyId={CompanyId}&CountryFrom={CountryFrom}&CountryTo={CountryTo}&CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}&AmountFrom={AmountFrom}&TypeDeliveryFrom={TypeDeliveryFrom}&TypeDeliveryTo={TypeDeliveryTo}

Parametrs

Field	Type	Description	Required
CompanyId	Number	Companies unique ID	Yes
CountryFrom	String	Code of sender country	Yes
CountryTo	String	Code of recipient country	Yes
CurrencyFrom	String	Code of sender currency	Yes
CurrencyTo	String	Code of recipient currency	Yes
AmountFrom	Decimal	Sending amount	Yes
TypeDeliveryFrom	String	Type of delivery	No
TypeDeliveryTo	String	Type of delivery	No

Code samples

curl -X GET \
  'https://api.remitradar.com/GetCompanyQuote?CompanyId={CompanyId}&CountryFrom={CountryFrom}&CountryTo={CountryTo}&CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}&AmountFrom={AmountFrom}&TypeDeliveryFrom={TypeDeliveryFrom}&TypeDeliveryTo={TypeDeliveryTo}' \
  -H 'accept: application/json' \
  -H 'x-api-key:Your_Secret_Key'

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
  .url("https://api.remitradar.com/GetCompanyQuote?CompanyId={CompanyId}&CountryFrom={CountryFrom}&CountryTo={CountryTo}&CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}&AmountFrom={AmountFrom}&TypeDeliveryFrom={TypeDeliveryFrom}&TypeDeliveryTo={TypeDeliveryTo}")
  .get()
  .addHeader("accept", "application/json")
  .addHeader("x-api-key", "Your_Secret_Key")
  .build();
Response response = client.newCall(request).execute();

package main
import (
	"fmt"
	"net/http"
	"io/ioutil"
)
func main() {
	url := "https://api.remitradar.com/GetCompanyQuote?CompanyId={CompanyId}&CountryFrom={CountryFrom}&CountryTo={CountryTo}&CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}&AmountFrom={AmountFrom}&TypeDeliveryFrom={TypeDeliveryFrom}&TypeDeliveryTo={TypeDeliveryTo}"
	req, _ := http.NewRequest("GET", url, nil)
	req.Header.Add("accept", "application/json")
	req.Header.Add("x-api-key", "Your_Secret_Key")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)
	fmt.Println(res)
	fmt.Println(string(body))
}

GET /GetCompanyQuote?CompanyId={CompanyId}&CountryFrom={CountryFrom}&CountryTo={CountryTo}&CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}&AmountFrom={AmountFrom}&TypeDeliveryFrom={TypeDeliveryFrom}&TypeDeliveryTo={TypeDeliveryTo} HTTP/1.1
Host: api.remitradar.com
Accept: application/json
x-api-key:Your_Secret_Key

var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
  if (this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.remitradar.com/GetCompanyQuote?CompanyId={CompanyId}&CountryFrom={CountryFrom}&CountryTo={CountryTo}&CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}&AmountFrom={AmountFrom}&TypeDeliveryFrom={TypeDeliveryFrom}&TypeDeliveryTo={TypeDeliveryTo}");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("x-api-key", "Your_Secret_Key");
xhr.send(data);

var client = new RestClient("https://api.remitradar.com/GetCompanyQuote?CompanyId={CompanyId}&CountryFrom={CountryFrom}&CountryTo={CountryTo}&CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}&AmountFrom={AmountFrom}&TypeDeliveryFrom={TypeDeliveryFrom}&TypeDeliveryTo={TypeDeliveryTo}");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "Your_Secret_Key");
request.AddHeader("accept", "application/json");
IRestResponse response = client.Execute(request);

setUrl('https://api.remitradar.com/GetCompanyQuote');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData(array(
  'CompanyId' => '{CompanyId}',
  'CountryFrom' => '{CountryFrom}',
  'CountryTo' => '{CountryTo}',
  'CurrencyFrom' => '{CurrencyFrom}',
  'CurrencyTo' => '{CurrencyTo}',
  'AmountFrom' => '{AmountFrom}',
  'TypeDeliveryFrom' => '{TypeDeliveryFrom}',
  'TypeDeliveryTo' => '{TypeDeliveryTo}'
));
$request->setHeaders(array(
  'x-api-key' => 'Your_Secret_Key',
  'accept' => 'application/json'
));
try {
  $response = $request->send();
  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
} ?>

var request = require("request");
var options = { method: 'GET',
  url: 'https://api.remitradar.com/GetCompanyQuote',
  qs: { CompanyId: '{CompanyId}', CountryFrom: '{CountryFrom}', CountryTo: '{CountryTo}', CurrencyFrom: '{CurrencyFrom}', CurrencyTo: '{CurrencyTo}', AmountFrom: '{AmountFrom}', TypeDeliveryFrom: '{TypeDeliveryFrom}', TypeDeliveryTo: '{TypeDeliveryTo}' },
  headers: 
   { 'x-api-key': 'Your_Secret_Key',
     accept: 'application/json' } };
request(options, function (error, response, body) {
  if (error) throw new Error(error);
  console.log(body);
});

import requests
url = "https://api.remitradar.com/GetCompanyQuote"
querystring = {"CompanyId":"{CompanyId}", "CountryFrom":"{CountryFrom}", "CountryTo":"{CountryTo}", "CurrencyFrom":"{CurrencyFrom}", "CurrencyTo":"{CurrencyTo}", "AmountFrom":"{AmountFrom}", "TypeDeliveryFrom":"{TypeDeliveryFrom}", "TypeDeliveryTo":"{TypeDeliveryTo}"}
headers = {
    'accept': "application/json",
    'x-api-key': "Your_Secret_Key"
    }
response = requests.request("GET", url, headers=headers, params=querystring)
print(response.text)

Success-Response:

{
    "Status":"Success",
    "Message":"",
    "Data": {
        "CompanyId": 11, 
        "CompanyName": "Kotak", 
        "CountryFrom": "AE", 
        "CountryTo": "IN", 
        "CurrencyFrom": "AED", 
        "CurrencyTo": "INR", 
        "TypeDeliveryFrom": "BANK_DEPOSIT", 
        "TypeDeliveryTo": "PHYSICAL_DELIVERY", 
        "TimeDeliveryFromSenderToCompany": "1-2 working days", 
        "TimeDeliveryFromCompanyToRecipient": "1-4 working days", 
        "AmountFrom": 1000, 
        "AmountTo": 17437.50, 
        "Rate": 17.4375, 
        "Fee": 0, 
        "FeeCurrency": "AED", 
        "RequestDate": "5/14/2017 1:22:49 PM", 
        "Message": null
    }
}

Error-Response:

{
    "Status": "Error", 
    "Message": "'AmountFrom' is not valid!", 
    "Data": null
}

GET Quotes

Returns all quotes for the selected corridor

https://api.remitradar.com/GetQuotes?CountryFrom={CountryFrom}&CountryTo={CountryTo}&CurrencyTo={CurrencyTo}&CurrencyFrom={CurrencyFrom}&AmountFrom={AmountFrom}

Parametrs

Field	Type	Description	Required
CountryFrom	String	Code of sender country	Yes
CountryTo	String	Code of recipient country	Yes
CurrencyFrom	String	Code of sender currency	Yes
CurrencyTo	String	Code of recipient currency	Yes
AmountFrom	Decimal	Sending amount	Yes

Code samples

curl -X GET \
  'https://api.remitradar.com/GetQuotes?CountryFrom={CountryFrom}&CountryTo={CountryTo}&CurrencyTo={CurrencyTo}&CurrencyFrom={CurrencyFrom}&AmountFrom={AmountFrom}' \
  -H 'accept: application/json' \
  -H 'x-api-key:Your_Secret_Key'

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
  .url("https://api.remitradar.com/GetQuotes?CountryFrom={CountryFrom}&CountryTo={CountryTo}&CurrencyTo={CurrencyTo}&CurrencyFrom={CurrencyFrom}&AmountFrom={AmountFrom}")
  .get()
  .addHeader("accept", "application/json")
  .addHeader("x-api-key", "Your_Secret_Key")
  .build();
Response response = client.newCall(request).execute();

package main
import (
	"fmt"
	"net/http"
	"io/ioutil"
)
func main() {
	url := "https://api.remitradar.com/GetQuotes?CountryFrom={CountryFrom}&CountryTo={CountryTo}&CurrencyTo={CurrencyTo}&CurrencyFrom={CurrencyFrom}&AmountFrom={AmountFrom}"
	req, _ := http.NewRequest("GET", url, nil)
	req.Header.Add("accept", "application/json")
	req.Header.Add("x-api-key", "Your_Secret_Key")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)
	fmt.Println(res)
	fmt.Println(string(body))
}

GET /GetQuotes?CountryFrom={CountryFrom}&CountryTo={CountryTo}&CurrencyTo={CurrencyTo}&CurrencyFrom={CurrencyFrom}&AmountFrom={AmountFrom} HTTP/1.1
Host: api.remitradar.com
Accept: application/json
x-api-key:Your_Secret_Key

var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
  if (this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.remitradar.com/GetQuotes?CountryFrom={CountryFrom}&CountryTo={CountryTo}&CurrencyTo={CurrencyTo}&CurrencyFrom={CurrencyFrom}&AmountFrom={AmountFrom}");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("x-api-key", "Your_Secret_Key");
xhr.send(data);

var client = new RestClient("https://api.remitradar.com/GetQuotes?CountryFrom={CountryFrom}&CountryTo={CountryTo}&CurrencyTo={CurrencyTo}&CurrencyFrom={CurrencyFrom}&AmountFrom={AmountFrom}");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "Your_Secret_Key");
request.AddHeader("accept", "application/json");
IRestResponse response = client.Execute(request);

setUrl('https://api.remitradar.com/GetQuotes');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData(array(
  'CountryFrom' => '{CountryFrom}',
  'CountryTo' => '{CountryTo}',
  'CurrencyFrom' => '{CurrencyFrom}',
  'CurrencyTo' => '{CurrencyTo}',
  'AmountFrom' => '{AmountFrom}'
));
$request->setHeaders(array(
  'x-api-key' => 'Your_Secret_Key',
  'accept' => 'application/json'
));
try {
  $response = $request->send();
  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
} ?>

var request = require("request");
var options = { method: 'GET',
  url: 'https://api.remitradar.com/GetQuotes',
  qs: { CountryFrom: '{CountryFrom}', CountryTo: '{CountryTo}', CurrencyFrom: '{CurrencyFrom}', CurrencyTo: '{CurrencyTo}', AmountFrom: '{AmountFrom}' },
  headers: 
   { 'x-api-key': 'Your_Secret_Key',
     accept: 'application/json' } };
request(options, function (error, response, body) {
  if (error) throw new Error(error);
  console.log(body);
});

import requests
url = "https://api.remitradar.com/GetQuotes"
querystring = {"CountryFrom":"{CountryFrom}", "CountryTo":"{CountryTo}", "CurrencyFrom":"{CurrencyFrom}", "CurrencyTo":"{CurrencyTo}", "AmountFrom":"{AmountFrom}"}
headers = {
    'accept': "application/json",
    'x-api-key': "Your_Secret_Key"
    }
response = requests.request("GET", url, headers=headers, params=querystring)
print(response.text)

Success-Response:

{
    "Status":"Success",
    "Message":"",
    "Data":[ {
        "CompanyId": 11, 
        "CompanyName": "Kotak", 
        "CountryFrom": "AE", 
        "CountryTo": "IN", 
        "CurrencyFrom": "AED", 
        "CurrencyTo": "INR", 
        "TypeDeliveryFrom": "BANK_DEPOSIT", 
        "TypeDeliveryTo": "BANK_DEPOSIT", 
        "TimeDeliveryFromSenderToCompany": "1-2 working days", 
        "TimeDeliveryFromCompanyToRecipient": "0-1 working days", 
        "AmountFrom": 1000, 
        "AmountTo": 17437.50, 
        "Rate": 17.4375, 
        "Fee": 0, 
        "FeeCurrency": "AED", 
        "RequestDate": "5/14/2017 1:36:22 PM", 
        "Message": ""
    }
    ,
    {
        "CompanyId": 28, 
        "CompanyName": "MoneyGram", 
        "CountryFrom": "AE", 
        "CountryTo": "IN", 
        "CurrencyFrom": "AED", 
        "CurrencyTo": "INR", 
        "TypeDeliveryFrom": "CASH_PICK_UP", 
        "TypeDeliveryTo": "CASH_PICK_UP", 
        "TimeDeliveryFromSenderToCompany": "Instant", 
        "TimeDeliveryFromCompanyToRecipient": "Instant", 
        "AmountFrom": 1000, 
        "AmountTo": 17343.33, 
        "Rate": 17.3433, 
        "Fee": 15.00, 
        "FeeCurrency": "AED", 
        "RequestDate": "5/14/2017 1:36:22 PM", 
        "Message": ""
    }
    ]
}

Error-Response:

{
    "Status": "Error", 
    "Message": "'CurrencyFrom' is not valid!", 
    "Data": null
}

GET AllQuotes

Returns all quotes for the selected corridor

https://api.remitradar.com/GetAllQuotes?CountryFrom={CountryFrom}&CountryTo={CountryTo}&AmountFrom={AmountFrom}

Parametrs

Field	Type	Description	Required
CountryFrom	String	Code of sender country	Yes
CountryTo	String	Code of recipient country	Yes
AmountFrom	Decimal	Sending amount	Yes

Code samples

curl -X GET \
  'https://api.remitradar.com/GetAllQuotes?CountryFrom={CountryFrom}&CountryTo={CountryTo}&AmountFrom={AmountFrom}' \
  -H 'accept: application/json' \
  -H 'x-api-key:Your_Secret_Key'

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
  .url("https://api.remitradar.com/GetAllQuotes?CountryFrom={CountryFrom}&CountryTo={CountryTo}&AmountFrom={AmountFrom}")
  .get()
  .addHeader("accept", "application/json")
  .addHeader("x-api-key", "Your_Secret_Key")
  .build();
Response response = client.newCall(request).execute();

package main
import (
	"fmt"
	"net/http"
	"io/ioutil"
)
func main() {
	url := "https://api.remitradar.com/GetAllQuotes?CountryFrom={CountryFrom}&CountryTo={CountryTo}&AmountFrom={AmountFrom}"
	req, _ := http.NewRequest("GET", url, nil)
	req.Header.Add("accept", "application/json")
	req.Header.Add("x-api-key", "Your_Secret_Key")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)
	fmt.Println(res)
	fmt.Println(string(body))
}

GET /GetAllQuotes?CountryFrom={CountryFrom}&CountryTo={CountryTo}&AmountFrom={AmountFrom} HTTP/1.1
Host: api.remitradar.com
Accept: application/json
x-api-key:Your_Secret_Key

var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
  if (this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.remitradar.com/GetAllQuotes?CountryFrom={CountryFrom}&CountryTo={CountryTo}&AmountFrom={AmountFrom}");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("x-api-key", "Your_Secret_Key");
xhr.send(data);

var client = new RestClient("https://api.remitradar.com/GetAllQuotes?CountryFrom={CountryFrom}&CountryTo={CountryTo}&AmountFrom={AmountFrom}");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "Your_Secret_Key");
request.AddHeader("accept", "application/json");
IRestResponse response = client.Execute(request);

setUrl('https://api.remitradar.com/GetAllQuotes');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData(array(
  'CountryFrom' => '{CountryFrom}',
  'CountryTo' => '{CountryTo}',
  'AmountFrom' => '{AmountFrom}'
));
$request->setHeaders(array(
  'x-api-key' => 'Your_Secret_Key',
  'accept' => 'application/json'
));
try {
  $response = $request->send();
  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
} ?>

var request = require("request");
var options = { method: 'GET',
  url: 'https://api.remitradar.com/GetAllQuotes',
  qs: { CountryFrom: '{CountryFrom}', CountryTo: '{CountryTo}', AmountFrom: '{AmountFrom}' },
  headers: 
   { 'x-api-key': 'Your_Secret_Key',
     accept: 'application/json' } };
request(options, function (error, response, body) {
  if (error) throw new Error(error);
  console.log(body);
});

import requests
url = "https://api.remitradar.com/GetAllQuotes"
querystring = {"CountryFrom":"{CountryFrom}", "CountryTo":"{CountryTo}", "AmountFrom":"{AmountFrom}"}
headers = {
    'accept': "application/json",
    'x-api-key': "Your_Secret_Key"
    }
response = requests.request("GET", url, headers=headers, params=querystring)
print(response.text)

Success-Response:

{
    "Status":"Success",
    "Message":"",
    "Data":[ {
        "CompanyId": 11, 
        "CompanyName": "Kotak", 
        "CountryFrom": "AE", 
        "CountryTo": "IN", 
        "CurrencyFrom": "AED", 
        "CurrencyTo": "INR", 
        "TypeDeliveryFrom": "BANK_DEPOSIT", 
        "TypeDeliveryTo": "BANK_DEPOSIT", 
        "TimeDeliveryFromSenderToCompany": "1-2 working days", 
        "TimeDeliveryFromCompanyToRecipient": "0-1 working days", 
        "AmountFrom": 1000, 
        "AmountTo": 17437.50, 
        "Rate": 17.4375, 
        "Fee": 0, 
        "FeeCurrency": "AED", 
        "RequestDate": "5/14/2017 1:36:22 PM", 
        "Message": ""
    }
    ,
    {
        "CompanyId": 28, 
        "CompanyName": "MoneyGram", 
        "CountryFrom": "AE", 
        "CountryTo": "IN", 
        "CurrencyFrom": "AED", 
        "CurrencyTo": "INR", 
        "TypeDeliveryFrom": "CASH_PICK_UP", 
        "TypeDeliveryTo": "CASH_PICK_UP", 
        "TimeDeliveryFromSenderToCompany": "Instant", 
        "TimeDeliveryFromCompanyToRecipient": "Instant", 
        "AmountFrom": 1000, 
        "AmountTo": 17343.33, 
        "Rate": 17.3433, 
        "Fee": 15.00, 
        "FeeCurrency": "AED", 
        "RequestDate": "5/14/2017 1:36:22 PM", 
        "Message": ""
    }
    ]
}

Error-Response:

{
    "Status": "Error", 
    "Message": "'CountryFrom' is not valid!", 
    "Data": null
}

GET MarketRate

Returns current exchange market rate

https://api.remitradar.com/GetMarketRate?CurrencyTo={CurrencyTo}&CurrencyFrom={CurrencyFrom}

Parametrs

Field	Type	Description	Required
CurrencyFrom	String	Code of sender currency	Yes
CurrencyTo	String	Code of recipient currency	Yes

Code samples

curl -X GET \
  'https://api.remitradar.com/GetMarketRate?CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}' \
  -H 'accept: application/json' \
  -H 'x-api-key:Your_Secret_Key'

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
  .url("https://api.remitradar.com/GetMarketRate?CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}")
  .get()
  .addHeader("accept", "application/json")
  .addHeader("x-api-key", "Your_Secret_Key")
  .build();
Response response = client.newCall(request).execute();

package main
import (
	"fmt"
	"net/http"
	"io/ioutil"
)
func main() {
	url := "https://api.remitradar.com/GetMarketRate?CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}"
	req, _ := http.NewRequest("GET", url, nil)
	req.Header.Add("accept", "application/json")
	req.Header.Add("x-api-key", "Your_Secret_Key")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)
	fmt.Println(res)
	fmt.Println(string(body))
}

GET /GetMarketRate?CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo} HTTP/1.1
Host: api.remitradar.com
Accept: application/json
x-api-key:Your_Secret_Key

var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
  if (this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.remitradar.com/GetMarketRate?CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("x-api-key", "Your_Secret_Key");
xhr.send(data);

var client = new RestClient("https://api.remitradar.com/GetMarketRate?CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "Your_Secret_Key");
request.AddHeader("accept", "application/json");
IRestResponse response = client.Execute(request);

setUrl('https://api.remitradar.com/GetMarketRate');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData(array(
  'CurrencyFrom' => '{CurrencyFrom}',
  'CurrencyTo' => '{CurrencyTo}'
));
$request->setHeaders(array(
  'x-api-key' => 'Your_Secret_Key',
  'accept' => 'application/json'
));
try {
  $response = $request->send();
  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
} ?>

var request = require("request");
var options = { method: 'GET',
  url: 'https://api.remitradar.com/GetMarketRate',
  qs: { CurrencyFrom: '{CurrencyFrom}', CurrencyTo: '{CurrencyTo}' },
  headers: 
   { 'x-api-key': 'Your_Secret_Key',
     accept: 'application/json' } };
request(options, function (error, response, body) {
  if (error) throw new Error(error);
  console.log(body);
});

import requests
url = "https://api.remitradar.com/GetMarketRate"
querystring = {"CurrencyFrom":"{CurrencyFrom}", "CurrencyTo":"{CurrencyTo}"}
headers = {
    'accept': "application/json",
    'x-api-key': "Your_Secret_Key"
    }
response = requests.request("GET", url, headers=headers, params=querystring)
print(response.text)

Success-Response:

{
    "Status":"Success",
    "Message":"",
    "Data":0.8907
}

Error-Response:

{
    "Status": "Error", 
    "Message": "'CurrencyFrom' is not valid!", 
    "Data": null
}

GET HistoricalMarketRates

Returns list of all exchange market rates during specified period

https://api.remitradar.com/GetHistoricalMarketRates?CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}&DateFrom={DateFrom}&DateTo={DateTo}

Parametrs

Field	Type	Description	Required
CurrencyFrom	String	Code of sender currency	Yes
CurrencyTo	String	Code of recipient currency	Yes
DateFrom	String	Begin of the period (dd-mm-yyyy)	Yes
DateTo	String	End of the period (dd-mm-yyyy)	Yes

Code samples

curl -X GET \
  'https://api.remitradar.com/GetHistoricalMarketRates?CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}&DateFrom={DateFrom}&DateTo={DateTo}' \
  -H 'accept: application/json' \
  -H 'x-api-key:Your_Secret_Key'

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
  .url("https://api.remitradar.com/GetHistoricalMarketRates?CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}&DateFrom={DateFrom}&DateTo={DateTo}")
  .get()
  .addHeader("accept", "application/json")
  .addHeader("x-api-key", "Your_Secret_Key")
  .build();
Response response = client.newCall(request).execute();

package main
import (
	"fmt"
	"net/http"
	"io/ioutil"
)
func main() {
	url := "https://api.remitradar.com/GetHistoricalMarketRates?CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}&DateFrom={DateFrom}&DateTo={DateTo}"
	req, _ := http.NewRequest("GET", url, nil)
	req.Header.Add("accept", "application/json")
	req.Header.Add("x-api-key", "Your_Secret_Key")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)
	fmt.Println(res)
	fmt.Println(string(body))
}

GET /GetHistoricalMarketRates?CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}&DateFrom={DateFrom}&DateTo={DateTo} HTTP/1.1
Host: api.remitradar.com
Accept: application/json
x-api-key:Your_Secret_Key

var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
  if (this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.remitradar.com/GetHistoricalMarketRates?CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}&DateFrom={DateFrom}&DateTo={DateTo}");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("x-api-key", "Your_Secret_Key");
xhr.send(data);

var client = new RestClient("https://api.remitradar.com/GetHistoricalMarketRates?CurrencyFrom={CurrencyFrom}&CurrencyTo={CurrencyTo}&DateFrom={DateFrom}&DateTo={DateTo}");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "Your_Secret_Key");
request.AddHeader("accept", "application/json");
IRestResponse response = client.Execute(request);

setUrl('https://api.remitradar.com/GetHistoricalMarketRates');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData(array(
  'CurrencyFrom' => '{CurrencyFrom}',
  'CurrencyTo' => '{CurrencyTo}',
  'DateFrom' => '{DateFrom}',
  'DateTo' => '{DateTo}'
));
$request->setHeaders(array(
  'x-api-key' => 'Your_Secret_Key',
  'accept' => 'application/json'
));
try {
  $response = $request->send();
  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
} ?>

var request = require("request");
var options = { method: 'GET',
  url: 'https://api.remitradar.com/GetHistoricalMarketRates',
  qs: { CurrencyFrom: '{CurrencyFrom}', CurrencyTo: '{CurrencyTo}', DateFrom: '{DateFrom}', DateTo: '{DateTo}' },
  headers: 
   { 'x-api-key': 'Your_Secret_Key',
     accept: 'application/json' } };
request(options, function (error, response, body) {
  if (error) throw new Error(error);
  console.log(body);
});

import requests
url = "https://api.remitradar.com/GetHistoricalMarketRates"
querystring = {"CurrencyFrom":"{CurrencyFrom}", "CurrencyTo":"{CurrencyTo}", "DateFrom":"{DateFrom}", "DateTo":"{DateTo}"}
headers = {
    'accept': "application/json",
    'x-api-key': "Your_Secret_Key"
    }
response = requests.request("GET", url, headers=headers, params=querystring)
print(response.text)

Success-Response:

{
    "Status":"Success",
    "Message":"",
    "Data":[ {
      "Date": "21-01-2017", 
      "Rate": 0.93478
    }
    ,
    {
      "Date": "22-01-2017", 
      "Rate": 0.93460
    }
    ,
    {
      "Date": "23-01-2017", 
      "Rate": 0.93236
    }
    ,
    {
      "Date": "24-01-2017", 
      "Rate": 0.92925
    }
    ,
    {
      "Date": "25-01-2017", 
      "Rate": 0.93222
    }
    ]
}

Error-Response:

{
    "Status": "Error", 
    "Message": "'25-01-017' is not in the correct format!", 
    "Data": null
}

Test api

Secret key:

Request type:

Required parameters:

Company:

Country from:

Country to:

Currency from:

Currency to:

Date from:

Date to:

Sending amount:

Optional parameters:

Delivery type from:

Delivery type to:

Send request

Request:

curl -X GET \
  'https://api.remitradar.com/GetCompanyCorridor?CompanyId={CompanyId}&CountryFrom={CountryFrom}&CountryTo={CountryTo}' \
  -H 'accept: application/json' \
  -H 'x-api-key:Your_Secret_Key'

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
  .url("https://api.remitradar.com/GetCompanyCorridor?CompanyId={CompanyId}&CountryFrom={CountryFrom}&CountryTo={CountryTo}")
  .get()
  .addHeader("accept", "application/json")
  .addHeader("x-api-key", "Your_Secret_Key")
  .build();
Response response = client.newCall(request).execute();

package main
import (
	"fmt"
	"net/http"
	"io/ioutil"
)
func main() {
	url := "https://api.remitradar.com/GetCompanyCorridor?CompanyId={CompanyId}&CountryFrom={CountryFrom}&CountryTo={CountryTo}"
	req, _ := http.NewRequest("GET", url, nil)
	req.Header.Add("accept", "application/json")
	req.Header.Add("x-api-key", "Your_Secret_Key")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)
	fmt.Println(res)
	fmt.Println(string(body))
}

GET /GetCompanyCorridor?CompanyId={CompanyId}&CountryFrom={CountryFrom}&CountryTo={CountryTo} HTTP/1.1
Host: api.remitradar.com
Accept: application/json
x-api-key:Your_Secret_Key

var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
  if (this.readyState === 4) {
    console.log(this.responseText);
  }
});
xhr.open("GET", "https://api.remitradar.com/GetCompanyCorridor?CompanyId={CompanyId}&CountryFrom={countryFrom}&CountryTo={countryTo}");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("x-api-key", "Your_Secret_Key");
xhr.send(data);

var client = new RestClient("https://api.remitradar.com/GetCompanyCorridor?CompanyId={CompanyId}&CountryFrom={countryFrom}&CountryTo={countryTo}");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "Your_Secret_Key");
request.AddHeader("accept", "application/json");
IRestResponse response = client.Execute(request);

setUrl('https://api.remitradar.com/GetCompanyCorridor');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData(array(
  'CompanyId' => '{CompanyId}',
  'CountryFrom' => '{CountryFrom}',
  'CountryTo' => {CountryTo}                                              
));
$request->setHeaders(array(
  'x-api-key' => 'Your_Secret_Key',
  'accept' => 'application/json'
));
try {
  $response = $request->send();
  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
} ?>

var request = require("request");
var options = { method: 'GET',
  url: 'https://api.remitradar.com/GetCompanyCorridor',
  qs: { CompanyId: '{CompanyId}', CountryTo : '{CountryTo}' , CountryFrom : '{CountryFrom}' },
  headers: 
   { 'x-api-key': 'Your_Secret_Key',
     accept: 'application/json' } };
request(options, function (error, response, body) {
  if (error) throw new Error(error);
  console.log(body);
});

import requests
url = "https://api.remitradar.com/GetCompanyCorridor"
querystring = {"CompanyId":"{CompanyId}" , "CountryFrom":"{CountryFrom}", "CountryTo" : "{CountryTo}"}
headers = {
    'accept': "application/json",
    'x-api-key': "Your_Secret_Key"
    }
response = requests.request("GET", url, headers=headers, params=querystring)
print(response.text)

Response: