Last updated: 3 June 2026
Nowadays, Django currency API integration has become common for modern applications. You can observe it especially in applications dealing with international financial data or e-commerce. Unlike a simple Python script, developers focus on performance, scalability, and architecture maintenance when implementing this integration.
In this tutorial, we explain Django currency API integration within an app. We will cover caching strategies, views, background updates using Celery, and API endpoints with Django REST framework. Let’s begin.
Prerequisites & Setup
- Python 3.x and Django installed in a virtual environment.
- Requests library: pip install requests
- Django REST Framework: pip install djangorestframework
- CurrencyFreaks API Key: Sign up to get your free API key.
- Celery: pip install celery
- Redis client: pip install redis
Fetching Rates in a Django View
Model-view-template is essential when working with the Django currency API. We do not follow hardcoding approaches. Instead, we focus on creating a structured view. This view fetches the data and passes it to the frontend.
views.py
from django.shortcuts import render
def exchange_dashboard(request):
data = get_cached_rates() # defined in "Caching Strategy" section below
context = {
'rates': data.get('rates'),
'base': data.get('base'),
'date': data.get('date')
}
return render(request, 'exchange/dashboard.html', context)
Your template (exchange/dashboard.html) allows you to access and navigate a rates dictionary while dynamically displaying currency values with Django template tags.
Note: In the next section, we'll define the get_cached_rates() function.
urls.py
from django.urls import path
from .views import exchange_dashboard
urlpatterns = [
path('dashboard/', exchange_dashboard, name='exchange-dashboard'),
]
Exchange Rate API Django — Caching Strategy
Django workflow for an exchange rate API should not include hitting external APIs on every single page load; as rates typically update every hour, Django's built-in cache framework can reduce latency and save on API credits. The CurrencyFreaks free plan includes 1,000 API calls per month, so caching allows thousands of users to share a single hourly API request.
from django.core.cache import cache
from django.conf import settings
import requests
def get_cached_rates():
rates = cache.get('latest_currency_rates')
if not rates:
api_key = settings.CURRENCYFREAKS_API_KEY
try:
response = requests.get(
f"https://api.currencyfreaks.com/v2.0/rates/latest?apikey={api_key}",
timeout=5
)
rates = response.json()
cache.set('latest_currency_rates', rates, 3600)
except requests.exceptions.RequestException:
return {}
return rates
Utilizing the cache.get()/cache.set() pattern ensures your application remains responsive even during high traffic volumes.
Building a Currency Conversion Endpoint with Django REST Framework
If you are developing an independent frontend or mobile app, a Django REST Framework currency API endpoint can help expose conversion logic as a professional JSON API.
serializers.py
from rest_framework import serializers
class ConversionSerializer(serializers.Serializer):
from_currency = serializers.CharField(max_length=3)
to_currency = serializers.CharField(max_length=3)
amount = serializers.FloatField()
views.py (DRF)
from rest_framework.views import APIView
from rest_framework.response import Response
class ConvertCurrency(APIView):
def get(self, request):
serializer = ConversionSerializer(data=request.query_params)
if not serializer.is_valid():
return Response(serializer.errors, status=400)
rates = get_cached_rates()
from_currency = serializer.validated_data['from_currency']
to_currency = serializer.validated_data['to_currency']
amount = serializer.validated_data['amount']
rates_data = rates.get('rates', {})
from_rate = rates_data.get(from_currency)
to_rate = rates_data.get(to_currency)
if from_rate is None or to_rate is None:
return Response(
{'error': 'Invalid or unsupported currency code'},
status=400
)
from_rate = float(from_rate)
to_rate = float(to_rate)
# Note: Formula assumes USD is the base currency from the API provider.
converted_amount = (amount / from_rate) * to_rate
return Response({
'from': from_currency,
'to': to_currency,
'amount': amount,
'converted_amount': round(converted_amount, 2)
})
This approach ensures your currency conversion Django logic remains organized and usable across applications.
urls.py (DRF Endpoint)
from django.urls import path
from .views import ConvertCurrency
urlpatterns = [
path('api/convert/', ConvertCurrency.as_view(), name='currency-convert'),
]
Example API Request
GET /api/convert/?from_currency=USD&to_currency=EUR&amount=100
JSON Response:
{
"from": "USD",
"to": "EUR",
"amount": 100.0,
"converted_amount": 91.23
}
Scheduled Rate Updates with Celery
For an optimal Django Celery exchange rates implementation, it is ideal to fetch rates in the background so as to maintain "warm" cache conditions while never having to wait on 3rd-party API responses. This way, users never need to wait in their search for rates from third parties.
tasks.py
from celery import shared_task
import requests
from django.core.cache import cache
from django.conf import settings
@shared_task
def update_rates_task():
api_key = settings.CURRENCYFREAKS_API_KEY
response = requests.get(f"https://api.currencyfreaks.com/v2.0/rates/latest?apikey={api_key}")
if response.status_code == 200:
cache.set('latest_currency_rates', response.json(), 3600)
Celery Beat Configuration (settings.py)
CELERY_BEAT_SCHEDULE = {
'update-rates-every-hour': {
'task': 'exchange.tasks.update_rates_task',
'schedule': 3600.0,
},
}
Celery Beat configuration is placed in settings.py so Django can register scheduled tasks correctly in production setups.
Add your API key in settings.py using environment variables:
# settings.py
import os
CURRENCYFREAKS_API_KEY = os.getenv("CURRENCYFREAKS_API_KEY")
This avoids exposing sensitive credentials in source control.
Error Handling & Production Readiness
In real-life scenarios, APIs may fail, so your Django app must gracefully handle currency conversion requests when they do so.
import requests
import logging
from rest_framework.views import APIView
from rest_framework.response import Response
from django.core.cache import cache
from .serializers import ConversionSerializer
logger = logging.getLogger(__name__)
class SafeConvertCurrency(APIView):
def get(self, request):
serializer = ConversionSerializer(data=request.query_params)
if not serializer.is_valid():
return Response(serializer.errors, status=400)
try:
rates = get_cached_rates()
except requests.exceptions.RequestException as e:
logger.error(f"Currency API failed: {e}")
rates = cache.get('latest_currency_rates')
if not rates:
return Response(
{'error': 'Exchange rate service unavailable'},
status=503
)
from_currency = serializer.validated_data['from_currency']
to_currency = serializer.validated_data['to_currency']
amount = serializer.validated_data['amount']
rates_data = rates.get('rates', {})
from_rate = rates_data.get(from_currency)
to_rate = rates_data.get(to_currency)
if from_rate is None or to_rate is None:
return Response(
{'error': 'Invalid or unsupported currency code'},
status=400
)
from_rate = float(from_rate)
to_rate = float(to_rate)
# Note: Formula assumes USD is the base currency from the API provider.
converted_amount = (amount / from_rate) * to_rate
return Response({
'from': from_currency,
'to': to_currency,
'amount': amount,
'converted_amount': round(converted_amount, 2)
})
By combining DRF as the interface, the Django Cache for performance, and Celery for background processing, you create a robust system capable of handling exchange rates with professionalism.
Conclusion
By aligning currency integration with Django's architecture, including views, caching, API endpoints, and background workers, you can avoid unnecessary API calls while increasing performance.
Django Cache reduces latency, Django REST Framework provides clean APIs, and Celery keeps exchange rates updated without blocking user requests, all making for an approach that is production-ready and scalable for applications handling real-time financial data.
FAQs
How Should I Handle Currency Conversion in Django Templates?
For best results, currency conversion should be handled using an exchange rate view context with either custom template filters or multiplication; for optimal UI, use a Django REST Framework endpoint that handles calculations via JavaScript instead. This ensures updated pricing doesn't necessitate full page reloads to display accurately.
Where Is the Best Place to Store Exchange Rates in Django?
For high-performance applications, temporary storage (e.g., 1 hour) should be handled using Redis or Memcached Cache; for historical reports or audit trails, however, rates should be stored in your primary database using an ExchangeRate model that updates regularly via Celery tasks.
Why Should I Use Celery for Currency Updates Instead of Updating on Page Load?
Updating on page load forces users to wait for third-party API responses, adding significant latency and risking a 504 Gateway Timeout if an API goes down. Django Celery exchange rates management allows you to fetch data in the background so your users always see a "warm" cache with no wait time for updates.
How Do I Handle API Rate Limits in a Django Project?
One effective strategy to remain within CurrencyFreaks plan limits is by employing a cache.get()/cache.set() cycle, checking cache first before only hitting the API when data has expired. This allows for thousands of users to be served using one API call per hour!
Is It Better to Use a Decimal or Float Field for Currency in Django Models?
Always use DecimalField when storing currency values in your models, since floats can lead to rounding errors that cause lost pennies. Also, ensure your currency conversion Django logic converts API responses into Decimals before performing calculations to maintain financial accuracy.
Sign Up for free at CurrencyFreaks and get your business's most accurate exchange rates.
Real-Life Applications Using Django
Django is widely used in various industries. Social networking sites like Instagram rely heavily on it. Its scalability supports millions of users without issues, making it suitable even for exchange rate conversions and financial tools.
E-commerce platforms like Shopify use Django. It helps manage internal databases, customer sales, and hidden fees professional level, ensuring smooth operations.
Content management systems (CMS) like Wagtail and Mezzanine are developed with Django. It also powers financial applications, booking systems, and education-based websites. Applications like these often benefit from integration with reliable sources like the European Central Bank for accurate data.
Django's flexibility and built-in security make it ideal. It supports high-end web-based application development with ease and accommodates features such as product management feature requests and a priority roadmap input, enhancing its adaptability for diverse use cases.
Why Should You Choose Django for currency API Integration?
Django is excellent for currency exchange API integration. It simplifies API requests through pre-installed modules, making it suitable for managing historical rates and monthly requests efficiently. This ensures fast retrieval and processing of currency data without hidden fees.
Its ORM (Object Relational Mapper) integrates seamlessly with various databases. This improves storage and data management, supporting tasks such as international sales for e-commerce stores and international brands.
Django prioritizes application security. It protects against threats like XSS, CSRF, and SQL injection. Users remain safe during transactions, even with a high requests volume.
Caching solutions enhance data-loading speed. Frequently changing views load without delays, which is critical for annual billing and quarterly briefing calls in business environments.
Django's modular structure allows easy modifications. Applications can be updated as needed for business requirements, offering platinum support click solutions for enhanced customer satisfaction.
The framework suits projects of any size. It handles real-time currency exchange rate applications effectively, including features like historical rates and high-volume monthly requests.
Currency APIs like CurrencyFreaks integrate seamlessly with Django. They provide up-to-date foreign exchange information for various applications. This includes international sales, financial transactions, and comprehensive currency exchange solutions.
How Do You Integrate CurrencyFreaks currency API with Django?
1. Set Up the Django Project
Step 1.1: Install Django
Install Django using pip:
pip install django
Step 1.2: Create a Django Project
Create a new Django project named currency_exchange:
django-admin startproject currency_exchange
cd currency_exchange
Step 1.3: Create a Django App
Create an app named exchange within your project:
python manage.py startapp exchange
2. Configure the Django Project
Step 2.1: Register the App
In currency_exchange/settings.py, add the exchange app to INSTALLED_APPS:
INSTALLED_APPS = [
...,
'exchange',
]
Step 2.2: Set Up URLs
Project URLs (currency_exchange/urls.py)
Update your urls.py file to include the app URLs and a homepage route:
from django.contrib import admin
from django.urls import path, include
from django.views.generic import TemplateView
urlpatterns = [
path('admin/', admin.site.urls),
path('api/', include('exchange.urls')), # API routes
path('', TemplateView.as_view(template_name='exchange/index.html'), name='home'), # Homepage
]
App URLs (exchange/urls.py)
Create a new urls.py file in the exchange app directory and add API routes for fetching currency data.
from django.urls import path
from . import views
urlpatterns = [
path('supported-currencies/', views.get_supported_currencies, name='supported_currencies'),
path('convert/', views.convert_currency, name='convert_currency'),
]
3. Backend Logic for APIs
Step 3.1: Add Views
In exchange/views.py, add the following views to handle API requests:
from django.http import JsonResponse
import requests
def get_supported_currencies(request):
api_key = 'your_currencyfreaks_api_key' # Replace with your API key
url = 'https://api.currencyfreaks.com/v2.0/supported-currencies'
response = requests.get(url)
if response.status_code == 200:
return JsonResponse(response.json())
return JsonResponse({'error': 'Failed to fetch supported currencies'}, status=500)
def convert_currency(request):
api_key = 'your_currencyfreaks_api_key' # Replace with your API key
from_currency = request.GET.get('from', 'USD')
to_currency = request.GET.get('to', 'EUR')
amount = float(request.GET.get('amount', 1))
url = f'https://api.currencyfreaks.com/v2.0/rates/latest?apikey={api_key}&base={from_currency}&symbols={to_currency}'
response = requests.get(url)
if response.status_code == 200:
data = response.json()
if to_currency in data.get('rates', {}):
rate = float(data['rates'][to_currency])
converted_amount = round(rate * amount, 2)
return JsonResponse({'from': from_currency, 'to': to_currency, 'rate': rate, 'converted_amount': converted_amount})
return JsonResponse({'error': 'Failed to fetch conversion rate'}, status=500)
4. Frontend (Single File)
Step 4.1: Create the HTML File
Place the HTML, CSS, and JavaScript code in a single file named index.html within the exchange/templates/exchange/ directory.
File: exchange/templates/exchange/index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Currency Exchange Rate Widget</title>
<style>
/* Embedded CSS */
body {
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
display: flex;
justify-content: center;
align-items: center;
height: 100vh;
margin: 0;
background: linear-gradient(135deg, green, black);
color: #333;
}
#currency-widget {
width: 360px;
padding: 30px;
border-radius: 15px;
background: #ffffff;
box-shadow: 0 8px 20px rgba(0, 0, 0, 0.2);
text-align: center;
}
h2 {
font-size: 2em;
color: #1f2937;
margin-bottom: 30px;
position: relative;
}
h2::after {
content: '';
width: 50px;
height: 3px;
background: #6dd5ed;
display: block;
margin: 0 auto;
margin-top: 10px;
}
label {
font-size: 1.1em;
color: #4b5563;
margin-bottom: 10px;
display: block;
}
select, input {
width: 100%;
padding: 12px;
margin-bottom: 25px;
border: 1px solid #d1d5db;
border-radius: 8px;
font-size: 1em;
background-color: #f1f5f9;
box-shadow: 0 4px 10px rgba(0, 0, 0, 0.1);
transition: box-shadow 0.3s ease;
}
select:focus, input:focus {
box-shadow: 0 6px 15px rgba(0, 0, 0, 0.15);
outline: none;
}
#result {
font-size: 1.5em;
font-weight: bold;
color: #1f2937;
margin-top: 20px;
}
#currency-widget button {
width: 100%;
padding: 12px;
background-color: #2193b0;
border: none;
border-radius: 8px;
color: white;
font-size: 1.2em;
cursor: pointer;
transition: background-color 0.3s ease;
}
#currency-widget button:hover {
background-color: #6dd5ed;
}
</style>
</head>
<body>
<div id="currency-widget">
<h2>Currency Exchange Rate</h2>
<label for="fromCurrency">From:</label>
<select id="fromCurrency"></select>
<label for="toCurrency">To:</label>
<select id="toCurrency"></select>
<label for="amount">Amount:</label>
<input type="number" id="amount" value="1">
<div id="result"></div>
<button id="convertButton">Convert</button>
</div>
</body>
</html>
5. Run the Project
Start the Django development server:
python manage.py runserver
Visit http://127.0.0.1:8000/ in your browser.
Conclusion
Integrating a currency API with Django is simple and efficient. Django's structured architecture makes connecting to APIs like CurrencyFreaks seamless. It enables real-time access to currency data for various applications, including e-commerce stores and commercial use.
The framework supports features like setting a base currency and retrieving data for a specific date, making it highly versatile. Django's scalability supports projects of any size, whether for small businesses or large-scale commercial use.
Its combination of a robust backend with a user-friendly frontend highlights Django's flexibility. Developers can take advantage of premium features for enhanced functionality. A dedicated support team is available to assist with integration challenges.
Django's built-in security features ensure safe data handling, even for applications requiring real-time updates during a quarterly briefing call. Its strong community and extensive documentation make it a reliable choice for developers. Quarterly briefing updates and scalable functionality further enhance its appeal.
FAQs
What is the best API for exchange rates?
CurrencyFreaks API offers accurate and real-time exchange rate data.
Is there a free exchange rate API?
Yes, CurrencyFreaks and ExchangeRate-API provide free plans for basic usage.
Is Google currency API free?
No, Google's currency API is not free; it requires payment.
What is the API exchange rate?
An exchange rate API fetches real-time currency conversion rates programmatically.
Sign Up for free at CurrencyFreaks and get your business's most accurate exchange rates.
