ExchangeRate-API Getting Started: Quickstart Guide (2026)

Getting started overview

Integrating ExchangeRate-API involves a few key steps: account registration, obtaining API credentials, and making an initial request. The API provides current and historical exchange rates for various currencies, suitable for applications requiring up-to-date financial data. The service offers a free tier allowing up to 1,500 requests per month, which is sufficient for initial development and testing.

ExchangeRate-API utilizes a RESTful architecture, returning data in JSON format, making it accessible across various programming environments. Developers can find comprehensive documentation and code examples for languages such as JavaScript, Python, and PHP on the official ExchangeRate-API documentation portal.

The following table outlines the foundational steps to begin using ExchangeRate-API:

Create an account and get keys

To access the ExchangeRate-API, you must first register for an account. This process typically involves providing an email address and creating a password. Upon successful registration, a unique API key is generated and made available in your account dashboard. This key authenticates your requests and tracks your usage against your plan limits.

1. Navigate to the Registration Page: Visit the official ExchangeRate-API registration page.
2. Complete Registration: Fill in the required details, which commonly include your email address and a secure password.
3. Verify Email (if required): Some services may require email verification before full access is granted. Check your inbox for a confirmation link.
4. Access Dashboard: After logging in, you will be redirected to your ExchangeRate-API dashboard.
5. Locate API Key: Your API key is prominently displayed within the dashboard. It is a string of alphanumeric characters, essential for all API calls. Keep this key confidential to prevent unauthorized usage of your account.

The API key is typically passed as part of the URL path in API requests. For example, a common endpoint structure might be https://v6.exchangerate-api.com/v6/YOUR_API_KEY_HERE/latest/USD, where YOUR_API_KEY_HERE is replaced with your actual key.

Your first request

After obtaining your API key, you can make your first request to retrieve current exchange rates. The primary endpoint for current rates is typically structured to provide the latest exchange rates for a specified base currency. This example demonstrates how to fetch the latest exchange rates with USD as the base currency.

API Endpoint Structure:

GET https://v6.exchangerate-api.com/v6/YOUR_API_KEY/latest/BASE_CURRENCY

Replace YOUR_API_KEY with your personal API key and BASE_CURRENCY with the three-letter ISO 4217 currency code (e.g., USD, EUR, GBP) for which you want to retrieve rates.

Example using cURL

cURL is a command-line tool and library for transferring data with URLs. It is commonly used for testing API endpoints because of its simplicity and widespread availability.

curl "https://v6.exchangerate-api.com/v6/YOUR_API_KEY/latest/USD"

Expected JSON Response (partial):

{
  "result": "success",
  "documentation": "https://www.exchangerate-api.com/docs",
  "terms_of_use": "https://www.exchangerate-api.com/terms",
  "time_last_update_unix": 1678886400,
  "time_last_update_utc": "Fri, 15 Mar 2023 00:00:00 +0000",
  "time_next_update_unix": 1678972800,
  "time_next_update_utc": "Sat, 16 Mar 2023 00:00:00 +0000",
  "base_code": "USD",
  "conversion_rates": {
    "USD": 1,
    "AED": 3.6725,
    "AFN": 87.75,
    "ALL": 95.89,
    "AMD": 388.5,
    "ANG": 1.79,
    "AOA": 500.0,
    "ARS": 105.0,
    // ... more currencies
  }
}

Example using Python

Python's requests library simplifies HTTP requests. Ensure you have it installed (pip install requests).

import requests
import json

api_key = "YOUR_API_KEY"
base_currency = "USD"
url = f"https://v6.exchangerate-api.com/v6/{api_key}/latest/{base_currency}"

try:
    response = requests.get(url)
    response.raise_for_status()  # Raise an HTTPError for bad responses (4xx or 5xx)
    data = response.json()
    print(json.dumps(data, indent=2))
except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")

Example using JavaScript (Node.js with node-fetch)

For Node.js environments, the node-fetch library (npm install node-fetch) provides a browser-compatible fetch API.

const fetch = require('node-fetch');

const apiKey = 'YOUR_API_KEY';
const baseCurrency = 'USD';
const url = `https://v6.exchangerate-api.com/v6/${apiKey}/latest/${baseCurrency}`;

async function getExchangeRates() {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data = await response.json();
    console.log(JSON.stringify(data, null, 2));
  } catch (error) {
    console.error('Error fetching exchange rates:', error);
  }
}

getExchangeRates();

Common next steps

After successfully making your first request, several common next steps can enhance your integration with ExchangeRate-API:

• Explore Historical Rates: The API supports requests for historical exchange rates, allowing you to retrieve data for specific past dates. This is useful for trend analysis, reporting, or calculating past transaction values. Details on historical rate endpoints are available in the ExchangeRate-API historical requests documentation.
• Implement Currency Conversion: Utilize the conversion endpoint to directly convert an amount from one currency to another. This simplifies calculations for e-commerce platforms or financial applications. Refer to the conversion requests documentation for usage examples.
• Error Handling: Implement robust error handling in your application to manage potential API issues, such as invalid API keys, rate limit exceedances, or invalid currency codes. The API typically returns descriptive error messages in its JSON responses.
• Rate Limit Management: Be aware of your plan's request limits. For the free tier, this is 1,500 requests per month. For paid tiers, such as the Starter plan, it increases to 20,000 requests per month (ExchangeRate-API pricing page). Implement caching mechanisms for frequently requested data to reduce API calls, or consider upgrading your plan if your usage exceeds current limits.
• Security Best Practices: Keep your API key confidential. Avoid hardcoding it directly into client-side code that could be publicly exposed. For server-side applications, use environment variables or a secure configuration management system to store your keys.
• Explore Webhooks (if available): Some APIs offer webhooks for real-time notifications of data changes or events. While not explicitly detailed for ExchangeRate-API in the provided entity, it is a common feature in similar financial APIs. If offered, webhooks can reduce polling and provide more immediate updates, as described in PayPal's webhook documentation.

Troubleshooting the first call

When making your first API call, you might encounter issues. Here are common problems and their solutions:

• Invalid API Key:
  • Symptom: The API returns an error indicating an invalid or missing API key, or a 403 Forbidden status code.
  • Solution: Double-check that you have copied your API key correctly from your ExchangeRate-API dashboard. Ensure there are no leading or trailing spaces. Verify that the key is correctly embedded in the URL path as specified in the documentation.
• Incorrect Endpoint URL:
  • Symptom: A 404 Not Found error or an empty/malformed response.
  • Solution: Compare your request URL against the examples in the ExchangeRate-API standard requests documentation. Ensure the version number (e.g., v6), API key placement, and base currency are correct.
• Rate Limit Exceeded:
  • Symptom: The API returns an error indicating that you have exceeded your daily or monthly request allowance, often with a 429 Too Many Requests status code.
  • Solution: If you are on the free tier, you might have hit the 1,500 requests/month limit. Wait until your usage resets or consider upgrading to a paid plan. For testing, spread out your requests or implement local caching.
• Invalid Base Currency Code:
  • Symptom: An error message indicating an invalid currency code or a 400 Bad Request.
  • Solution: Ensure the base currency code is a valid ISO 4217 three-letter code (e.g., USD, EUR, JPY). Check for typos.
• Network Issues:
  • Symptom: Connection timeouts or inability to reach the API server.
  • Solution: Verify your internet connection. If running in a restricted network environment, check firewall rules or proxy settings that might be blocking outbound HTTP/HTTPS requests.
• JSON Parsing Errors:
  • Symptom: Your application fails to parse the API response, indicating malformed JSON.
  • Solution: This typically happens if the API returned an error page (e.g., HTML) instead of JSON. Inspect the raw response content. If the response is valid JSON, ensure your parsing logic is correct for the programming language you are using.