Have you ever considered integrating a currency converter into a Node.js application using Express? CurrencyFreaks has a free and reliable API to help more apps that need real-time currency conversion. This blog will show you the ‘CurrencyFreaks Free Currency Converter API’ integration with Node JS. We’ll make sure it’s simple and efficient.
We will walk you through setting up your Node.js environment, fetching live exchange rates using Axios, and handling API responses effectively.
If you're exploring other backend implementations, you can also check out our Python-based currency converter integration guide.
How to Integrate Currency Converter API in Node.js (Step-by-Step)
Below are the simple steps to achieving CurrencyFreaks integration with Node JS. Let’s get started.
Get Your API Key
Get your API key by creating an account at https://currencyfreaks.com/. You can log in to the dashboard where you will see the API key. You will see something like this:
- You can quickly test your API key by opening the following endpoint in your browser or Postman.
👉Access all CurrencyFreaks endpoints with the CurrencyFreaks documentation.
Set Up Node.js Environment for Currency API Integration
First, ensure you have Node.js installed, then set up a new Node.js project. Run the commands below in the Command Prompt and open it inside Visual Studio Code.
mkdir currency-converter-node
cd currency-converter-node
npm init -y
npm install express axios
Next, you should create a new file named server.js in the project directory. Below is a complete working Node.js example using Express and Axios to fetch real-time exchange rates.
// server.js
require('dotenv').config();
const express = require('express');
const axios = require('axios');
const path = require('path');
const app = express();
const port = 3000;
const apiKey = process.env.CURRENCYFREAKS_API_KEY; // Replace with your actual API key
app.use(express.json());
app.use(express.static(path.join(__dirname, 'public')));
app.get('/', (req, res) => {
res.sendFile(path.join(__dirname, 'public', 'index.html'));
});
app.post('/convert', async (req, res) => {
const { amount, fromCurrency, toCurrency } = req.body;
try {
const response = await axios.get(`https://api.currencyfreaks.com/v2.0/rates/latest?apikey=${apiKey}&base=${fromCurrency}`);
const rates = response.data.rates;
const exchangeRate = rates[toCurrency];
if (exchangeRate) {
const convertedAmount = (amount * exchangeRate).toFixed(2);
res.json({ amount, fromCurrency, toCurrency, convertedAmount });
} else {
res.status(400).json({ error: 'Invalid toCurrency code' });
}
} catch (error) {
res.status(500).json({ error: 'Error fetching exchange rates' });
}
});
app.listen(port, () => {
console.log(`Server is running on http://localhost:${port}`);
});
Using CurrencyFreaks API in Express Middleware (Server-Side Conversion)
In Node.js applications, one powerful approach is to handle currency conversion directly on the server using Express middleware. This allows you to cache exchange rates at the middleware level, reducing repeated API calls and improving response performance in production applications.
Here is a simple example of middleware that fetches exchange rates:
// middleware/exchangeRate.js
require('dotenv').config();
const axios = require('axios');
const apiKey = process.env.CURRENCYFREAKS_API_KEY;
// Simple in-memory cache
let cache = {};
const CACHE_TTL = 10 * 60 * 1000; // 10 minutes
const getExchangeRates = async (req, res, next) => {
try {
const fromCurrency = req.body.fromCurrency || req.query.fromCurrency;
const now = Date.now();
if (
cache[fromCurrency] &&
now - cache[fromCurrency].lastFetched < CACHE_TTL
) {
req.rates = cache[fromCurrency].rates;
return next();
}
const response = await axios.get(
`https://api.currencyfreaks.com/v2.0/rates/latest?apikey=${apiKey}&base=${fromCurrency}`
);
cache[fromCurrency] = {
rates: response.data.rates,
lastFetched: now,
};
req.rates = cache[fromCurrency].rates;
next();
} catch (error) {
res.status(500).json({ error: 'Failed to fetch exchange rates' });
}
};
module.exports = getExchangeRates;
This approach improves performance and keeps your currency conversion logic centralized on the server.
The next step is to create an index.html file. You also need to create a CSS file and name it styles.css. It will enhance the appearance of your application.
Index.html
Create a public directory in your project root and add index.html and styles.css files.
Here is the code for index.html file:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Currency Converter</title>
<link rel="stylesheet" href="styles.css">
</head>
<body>
<div class="container">
<h1>Currency Converter</h1>
<form id="converter-form">
<input type="number" id="amount" placeholder="Amount" required>
<input type="text" id="fromCurrency" placeholder="From Currency (e.g., USD)" required>
<input type="text" id="toCurrency" placeholder="To Currency (e.g., EUR)" required>
<button type="submit">Convert</button>
</form>
<h2 id="result"></h2>
</div>
<script>
document.getElementById('converter-form').addEventListener('submit', async (e) => {
e.preventDefault();
const amount = document.getElementById('amount').value;
const fromCurrency = document.getElementById('fromCurrency').value;
const toCurrency = document.getElementById('toCurrency').value;
const response = await fetch('/convert', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({ amount, fromCurrency, toCurrency }),
});
const data = await response.json();
if (response.ok) {
document.getElementById('result').textContent = `${amount} ${fromCurrency} is equal to ${data.convertedAmount} ${toCurrency}`;
} else {
document.getElementById('result').textContent = `Error: ${data.error}`;
}
});
</script>
</body>
</html>
Styles.css
Here is the code for styles.css file:
body {
font-family: Arial, sans-serif;
background-color: #f4f4f9;
color: #333;
margin: 0;
padding: 0;
display: flex;
justify-content: center;
align-items: center;
height: 100vh;
}
h1 {
color: #5a67d8;
}
.container {
background: white;
padding: 20px;
border-radius: 8px;
box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
text-align: center;
}
form {
display: flex;
flex-direction: column;
align-items: center;
}
input[type="number"],
input[type="text"] {
width: 300px;
padding: 10px;
margin: 10px 0;
border: 1px solid #ddd;
border-radius: 4px;
font-size: 1em;
}
button {
background-color: #5a67d8;
color: white;
padding: 10px 20px;
border: none;
border-radius: 4px;
font-size: 1em;
cursor: pointer;
margin-top: 10px;
}
button:hover {
background-color: #434190;
}
#result {
margin-top: 20px;
font-size: 1.2em;
}
Finally, you must start the server by running the below code:
node server.js
Open your web browser and navigate to http://localhost:3000. You should see the styled currency converter form. Fill out the form and submit it to see the converted currency.
Output
Why Is Node.js Ideal for Currency Converter API Integration?
Many developers choose Node.js for currency converter applications because of its event-driven, non-blocking architecture, which efficiently handles multiple concurrent API requests. This makes it well-suited for real-time applications that rely on frequent external data updates.
Additionally, Node.js has a strong ecosystem through npm. As a result, it allows developers to quickly integrate tools like Axios for API communication and build scalable backend services with minimal setup.
Conclusion
Integrating the CurrencyFreaks API with Node.js is a simple way to build a server-side currency converter using Express and Axios. This guide presents you with step-by-step instructions on how to achieve this. It can be realized through its fastness by managing several tasks simultaneously in an event-driven manner within Node JS.
The live exchange rates from CurrencyFreaks make your app more powerful and user-friendly. Follow these steps to integrate the API and enhance your application with up-to-date currency information. You can also explore other options in our guide on the best currency exchange APIs available.
FAQs
Why Use Node.js for a Currency Converter API?
Node.js is a strong choice for building a currency converter because it can handle multiple requests efficiently using its non-blocking architecture. It also offers a wide range of npm packages, making it easier to work with real-time data and integrate APIs like CurrencyFreaks.
How to Fetch Exchange Rates in Node.js Using Currency API?
You can easily fetch live currency rates using the CurrencyFreaks API via Node JS. First, install Axios. Next, send a GET request to the API. Finally, read JSON response in order to get currency rates.
What Are Best Practices for Handling Currency Data in Node.js Applications?
- Store often-used data in the cache.
- Check and clean all data inputs.
- Update exchange rates regularly.
- Manage errors carefully.
- Keep API keys secure by storing them in a .env file and using environment variables (process.env).
- Use encryption to protect data.
How to Handle Errors in Node.js Currency Converter API Integration?
To handle errors with CurrencyFreaks API in Node JS, use try-catch blocks to catch mistakes. Retry failed requests. Check API responses for correct data. This ensures your currency conversion works reliably.
What is the Best Currency Converter API for Node.js?
CurrencyFreaks is a reliable option for Node.js applications as it provides real-time exchange rates, simple REST endpoints, and easy integration using Axios or fetch.
