Pricing

Exchange Rates API Documentation

Access real-time exchange rates for currencies & crypto. This API provides accurate, up-to-date rates for integrating into your financial applications.

Below are the endpoints for accessing exchange rates. Learn how to integrate the API into your application.

Authorization:

  • privateId *Specify privateId for site
    (e.g., "Bearer example^com-SomeIdString").

Query Parameters:

  • show Specify which rates to show
    (e.g., "all"|"rates"|"crypto").
  • list Comma-separated list of currency codes
    (e.g., "USD,INR,BTC").

Route Parameters:

  • :region *Please check location table here
    (e.g., "WEST_3|ARAB_1|EAST_3|NORD_6").

Response based on params:

{
  "success": true,
  "data": {
    "rates": {
      "USD": 1,
      "INR": 83.540592,
      "JPY": 143.662125,
      "BTC": 0.000015737383
    },
    "crypto": {
      "BTC": 63478.467340116214,
      "DOGE": 0.012578131058644222
    }
  }
}

GET

NoAuthLoyaltyEnterprise

This endpoint provides the current exchange rates for the requested currencies.

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
)

func main() {
    result, err := fetchData()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    prettyJSON, _ := json.MarshalIndent(result, "", "  ")
    fmt.Println(string(prettyJSON))
}

func fetchData() (map[string]interface{}, error) {
    // API configuration
    baseURL := "https://exchangegrid.api.mapwale.com/v1"
    params := map[string]string{
        "region": "YOUR_REGION", // Replace with actual region value
    }
    headers := map[string]string{
        "Content-Type":  "application/json",
        "Authorization": "Bearer <privateId>",
    }
    queryParams := {"show":"all","list":"USD,INR,JPY,BTC,DOGE"}

    // Build URL
    urlBuilder, err := url.Parse(baseURL)
    if err != nil {
        return nil, err
    }

    // Add path parameters
    pathParams := ["region"]
    path := urlBuilder.Path
    for _, param := range pathParams {
        path += "/" + url.PathEscape(params[param])
    }
    urlBuilder.Path = path

    // Add query parameters
    q := urlBuilder.Query()
    for key, value := range queryParams {
        q.Add(key, value)
    }
    urlBuilder.RawQuery = q.Encode()

    // Create request body for POST/PUT
    var reqBody []byte
    if "GET" == "POST" || "GET" == "PUT" {
        reqBody, err = json.Marshal({})
        if err != nil {
            return nil, err
        }
    }

    // Create request
    req, err := http.NewRequest("GET", urlBuilder.String(), bytes.NewBuffer(reqBody))
    if err != nil {
        return nil, err
    }

    // Set headers
    for key, value := range headers {
        req.Header.Set(key, value)
    }

    // Send request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    // Check for errors
    if resp.StatusCode >= 400 {
        return nil, fmt.Errorf("HTTP error! status: %d", resp.StatusCode)
    }

    // Read response
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    // Parse JSON response
    var result map[string]interface{}
    err = json.Unmarshal(body, &result)
    if err != nil {
        return nil, err
    }

    return result, nil
}

Explore usecase

Page-Run SSR