Fast, Reliable Foreign Exchange Data API

// Get the latest exchange rates (Node.js)
import fetch from 'node-fetch';

async function getLatestRates() {
    const base = 'USD';
    const url = `https://api.openexchangeapi.com/v1/latest?base=${base}`;

    try {
        const res = await fetch(url);

        if (!res.ok) {
            throw new Error(`HTTP ${res.status}`);
        }

        const data = await res.json();

        console.log(`Base currency: ${data.base}`);
        console.log(`Date: ${data.date}`);
        console.log('Exchange rates:');

        for (const [currency, rate] of Object.entries(data.rates)) {
            console.log(`${currency}: ${rate}`);
        }
    } catch (err) {
        console.error('Error:', err.message);
    }
}

getLatestRates();

# Get the latest exchange rates
import requests

base_currency = 'USD'
url = f'https://api.openexchangeapi.com/v1/latest?base={base_currency}'

response = requests.get(url)

if response.status_code != 200:
    print(f'API Error: HTTP {response.status_code}')
else:
    data = response.json()
    print(f"Base currency: {data['base']}")
    print(f"Date: {data['date']}")
    print("Exchange rates:")

    for currency, rate in data['rates'].items():
        print(f"{currency}: {rate}")

// Get the latest exchange rates (Go)
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "io"
)

func main() {
    base := "USD"
    url := fmt.Sprintf("https://api.openexchangeapi.com/v1/latest?base=%s", base)

    res, err := http.Get(url)
    if err != nil {
        fmt.Println("Request error:", err)
        return
    }
    defer res.Body.Close()

    if res.StatusCode != http.StatusOK {
        fmt.Println("API Error: HTTP", res.StatusCode)
        return
    }

    body, _ := io.ReadAll(res.Body)

    var data map[string]interface{}
    json.Unmarshal(body, &data)

    fmt.Println("Base currency:", data["base"])
    fmt.Println("Date:", data["date"])
    fmt.Println("Exchange rates:")

    if rates, ok := data["rates"].(map[string]interface{}); ok {
        for currency, rate := range rates {
            fmt.Printf("%s: %v\n", currency, rate)
        }
    }
}

// Get the latest exchange rates
use reqwest;
use serde_json::Value;
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let base = "USD";
    let url = format!("https://api.openexchangeapi.com/v1/latest?base={}", base);

    let response = reqwest::get(&url).await?;

    if !response.status().is_success() {
        println!("API Error: HTTP ", response.status());
        return Ok(());
    }

    let body = response.text().await?;
    let data: Value = serde_json::from_str(&body)?;

    println!("Base currency: {}", data["base"]);
    println!("Date: {}", data["date"]);
    println!("Exchange rates:");

    if let Some(rates) = data["rates"].as_object() {
        for (currency, rate) in rates {
            println!("{}: {}", currency, rate);
        }
    }

    Ok(())
}

// Get the latest exchange rates (PHP)
$base = 'USD';
$url = "https://api.openexchangeapi.com/v1/latest?base={$base}";

$context = stream_context_create([
    'http' => [
        'ignore_errors' => true
    ]
]);

$response = file_get_contents($url, false, $context);
$status_line = $http_response_header[0] ?? '';

if (strpos($status_line, '200') === false) {
    echo "API Error: {$status_line}\n";
    return;
}

$data = json_decode($response, true);

echo "Base currency: {$data['base']}\n";
echo "Date: {$data['date']}\n";
echo "Exchange rates:\n";

foreach ($data['rates'] as $currency => $rate) {
    echo "{$currency}: {$rate}\n";
}

# Get the latest exchange rates (Ruby)
require 'net/http'
require 'json'
require 'uri'

base = 'USD'
url = URI("https://api.openexchangeapi.com/v1/latest?base={base}")

res = Net::HTTP.get_response(url)

if res.code != '200'
  puts "API Error: HTTP {res.code}"
  exit
end

data = JSON.parse(res.body)

puts "Base currency: {data['base']}"
puts "Date: {data['date']}"
puts "Exchange rates:"

data['rates'].each do |currency, rate|
  puts "{currency}: {rate}"
end