Building a Multi-Currency Pricing System with REST APIs

E-commerce platforms serving global markets face unique pricing challenges. A product priced at $99 USD needs to display correctly as €89 EUR, £79 GBP, or ¥11,000 JPY depending on the customer's location. But it's not just about conversion - you need to handle dynamic pricing strategies, regional pricing variations, promotional discounts across currencies, and real-time exchange rate updates.

This guide walks through building a production-ready multi-currency pricing system that handles millions of products, supports 160+ currencies, processes thousands of price updates per second, and maintains sub-100ms API response times. We'll cover the complete architecture from database schema to API design to caching strategies.

1. Multi-Currency Architecture Patterns

Three Pricing Model Approaches

Before designing your API, choose the right pricing model for your business:

API-First Architecture

Modern pricing systems should be built API-first with these components:

┌─────────────────────────────────────────────────┐
│           Frontend Applications                  │
│  (Web, Mobile, Point of Sale, Partner APIs)     │
└──────────────────┬──────────────────────────────┘
                   │
        ┌──────────▼──────────┐
        │  API Gateway Layer   │
        │  (Rate Limiting,     │
        │   Authentication)    │
        └──────────┬───────────┘
                   │
        ┌──────────▼──────────────────┐
        │   Pricing Service API       │
        │  /v1/products/{id}/price    │
        │  /v1/convert                │
        │  /v1/rates                  │
        └──────────┬──────────────────┘
                   │
        ┌──────────▼──────────────────┐
        │    Cache Layer (Redis)      │
        │  - Exchange rates (1hr TTL) │
        │  - Product prices (5min)    │
        └──────────┬──────────────────┘
                   │
    ┌──────────────┼──────────────┐
    │              │              │
┌───▼────┐  ┌──────▼─────┐  ┌───▼──────┐
│Product │  │ Exchange   │  │ Historical│
│  DB    │  │ Rate API   │  │ Rates DB  │
└────────┘  └────────────┘  └───────────┘

2. Database Design for Multi-Currency Products

Schema for Hybrid Pricing Model

This schema supports all three pricing models and scales to millions of products:

-- Products with base pricing
CREATE TABLE products (
    id BIGSERIAL PRIMARY KEY,
    sku VARCHAR(100) UNIQUE NOT NULL,
    name VARCHAR(500) NOT NULL,
    base_price NUMERIC(19,4) NOT NULL,
    base_currency CHAR(3) NOT NULL DEFAULT 'USD',
    price_type VARCHAR(20) DEFAULT 'dynamic',
    active BOOLEAN DEFAULT true,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,

    CONSTRAINT valid_base_currency CHECK (base_currency ~ '^[A-Z]{3}$'),
    CONSTRAINT valid_price_type CHECK (price_type IN ('dynamic', 'fixed', 'hybrid'))
);

CREATE INDEX idx_products_sku ON products(sku);
CREATE INDEX idx_products_active ON products(active) WHERE active = true;

-- Regional price overrides
CREATE TABLE product_prices_regional (
    id BIGSERIAL PRIMARY KEY,
    product_id BIGINT REFERENCES products(id) ON DELETE CASCADE,
    currency CHAR(3) NOT NULL,
    price NUMERIC(19,4) NOT NULL,
    margin_percent NUMERIC(5,2),
    country_code CHAR(2),  -- ISO 3166-1 alpha-2
    active BOOLEAN DEFAULT true,
    valid_from TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    valid_until TIMESTAMP,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,

    CONSTRAINT valid_currency CHECK (currency ~ '^[A-Z]{3}$'),
    CONSTRAINT valid_price CHECK (price >= 0),
    UNIQUE(product_id, currency, country_code)
);

CREATE INDEX idx_regional_prices_lookup
ON product_prices_regional(product_id, currency, country_code)
WHERE active = true;

-- Exchange rate cache table
CREATE TABLE exchange_rates_cache (
    id BIGSERIAL PRIMARY KEY,
    base_currency CHAR(3) NOT NULL,
    target_currency CHAR(3) NOT NULL,
    rate NUMERIC(19,6) NOT NULL,
    source VARCHAR(50) NOT NULL,
    fetched_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    expires_at TIMESTAMP NOT NULL,

    CONSTRAINT valid_rate CHECK (rate > 0),
    UNIQUE(base_currency, target_currency, source)
);

CREATE INDEX idx_rates_lookup
ON exchange_rates_cache(base_currency, target_currency, expires_at);

-- Price change audit log
CREATE TABLE price_change_log (
    id BIGSERIAL PRIMARY KEY,
    product_id BIGINT REFERENCES products(id),
    currency CHAR(3) NOT NULL,
    old_price NUMERIC(19,4),
    new_price NUMERIC(19,4) NOT NULL,
    change_reason VARCHAR(200),
    changed_by VARCHAR(100),
    changed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE INDEX idx_price_log_product ON price_change_log(product_id, changed_at);

-- Sample data
INSERT INTO products (sku, name, base_price, base_currency, price_type) VALUES
('PROD-001', 'Premium Subscription Monthly', 99.00, 'USD', 'hybrid'),
('PROD-002', 'Enterprise License Annual', 1200.00, 'USD', 'fixed'),
('PROD-003', 'Starter Plan', 19.00, 'USD', 'dynamic');

-- Regional pricing overrides for competitive markets
INSERT INTO product_prices_regional (product_id, currency, price, country_code) VALUES
(1, 'EUR', 89.00, 'DE'),  -- €89 instead of converted €92
(1, 'GBP', 79.00, 'GB'),  -- £79 instead of converted £82
(1, 'JPY', 11000, 'JP');  -- ¥11,000 psychological pricing

Indexing Strategy for Performance

Proper indexing is critical when serving millions of price lookups per day:

• Product SKU Index: Most lookups use SKU rather than ID in APIs
• Active Products Filter: Partial index for only active products reduces index size by 30-40%
• Regional Price Composite Index: Covers all query parameters for zero I/O lookups
• Exchange Rate Expiry Index: Enables fast cleanup of expired rates

3. REST API Integration Strategies

Designing Your Pricing API Endpoints

Well-designed API endpoints make integration simple for frontend developers:

# Get product price in specific currency
GET /v1/products/{sku}/price?currency=EUR&country=DE
Response: {
  "sku": "PROD-001",
  "price": 89.00,
  "currency": "EUR",
  "pricing_type": "regional_override",
  "base_price": 99.00,
  "base_currency": "USD",
  "exchange_rate": 0.9282,
  "last_updated": "2026-01-30T10:15:00Z"
}

# Bulk price lookup (for catalog pages)
POST /v1/products/prices
{
  "skus": ["PROD-001", "PROD-002", "PROD-003"],
  "currency": "GBP",
  "country": "GB"
}
Response: {
  "prices": [
    {"sku": "PROD-001", "price": 79.00, "currency": "GBP"},
    {"sku": "PROD-002", "price": 949.00, "currency": "GBP"},
    {"sku": "PROD-003", "price": 15.00, "currency": "GBP"}
  ],
  "exchange_rate": 0.7921,
  "cached": true
}

# Currency conversion endpoint
GET /v1/convert?amount=99.00&from=USD&to=EUR
Response: {
  "original_amount": 99.00,
  "original_currency": "USD",
  "converted_amount": 91.89,
  "target_currency": "EUR",
  "rate": 0.9282,
  "rate_source": "ecb",
  "timestamp": "2026-01-30T10:15:00Z"
}

# List supported currencies
GET /v1/currencies
Response: {
  "currencies": [
    {
      "code": "USD",
      "name": "US Dollar",
      "symbol": "$",
      "decimal_places": 2
    },
    {
      "code": "EUR",
      "name": "Euro",
      "symbol": "€",
      "decimal_places": 2
    }
  ]
}

Python Implementation with Flask

from flask import Flask, request, jsonify
from decimal import Decimal
import redis
import requests
from datetime import datetime, timedelta
import psycopg2
from psycopg2.extras import RealDictCursor

app = Flask(__name__)
redis_client = redis.Redis(host='localhost', port=6379, db=0)

class PricingService:
    """
    Multi-currency pricing service with caching and fallbacks.
    """

    def __init__(self, db_connection, redis_client, api_key):
        self.db = db_connection
        self.redis = redis_client
        self.api_key = api_key
        self.rate_cache_ttl = 3600  # 1 hour

    def get_product_price(self, sku: str, currency: str, country: str = None) -> dict:
        """
        Get product price with regional overrides and currency conversion.
        """
        # Check cache first
        cache_key = f"price:{sku}:{currency}:{country or 'global'}"
        cached = self.redis.get(cache_key)
        if cached:
            return eval(cached.decode('utf-8'))

        # Get base product
        with self.db.cursor(cursor_factory=RealDictCursor) as cur:
            cur.execute(
                "SELECT * FROM products WHERE sku = %s AND active = true",
                (sku,)
            )
            product = cur.fetchone()

        if not product:
            raise ValueError(f"Product {sku} not found")

        # Check for regional override
        if product['price_type'] in ('fixed', 'hybrid'):
            override = self._get_regional_override(
                product['id'], currency, country
            )
            if override:
                result = {
                    'sku': sku,
                    'price': float(override['price']),
                    'currency': currency,
                    'pricing_type': 'regional_override',
                    'base_price': float(product['base_price']),
                    'base_currency': product['base_currency']
                }
                self.redis.setex(cache_key, 300, str(result))  # 5min cache
                return result

        # Dynamic conversion
        if product['base_currency'] == currency:
            converted_price = product['base_price']
            rate = Decimal('1')
        else:
            rate = self.get_exchange_rate(product['base_currency'], currency)
            converted_price = product['base_price'] * rate
            converted_price = self._round_to_currency(converted_price, currency)

        result = {
            'sku': sku,
            'price': float(converted_price),
            'currency': currency,
            'pricing_type': 'dynamic_conversion',
            'base_price': float(product['base_price']),
            'base_currency': product['base_currency'],
            'exchange_rate': float(rate),
            'last_updated': datetime.utcnow().isoformat()
        }

        self.redis.setex(cache_key, 300, str(result))
        return result

    def _get_regional_override(self, product_id: int, currency: str, country: str):
        """Check for regional price override."""
        with self.db.cursor(cursor_factory=RealDictCursor) as cur:
            cur.execute("""
                SELECT * FROM product_prices_regional
                WHERE product_id = %s
                AND currency = %s
                AND (country_code = %s OR country_code IS NULL)
                AND active = true
                AND (valid_until IS NULL OR valid_until > NOW())
                ORDER BY country_code DESC NULLS LAST
                LIMIT 1
            """, (product_id, currency, country))
            return cur.fetchone()

    def get_exchange_rate(self, from_currency: str, to_currency: str) -> Decimal:
        """
        Get exchange rate with caching and API fallback.
        """
        if from_currency == to_currency:
            return Decimal('1')

        # Check Redis cache
        cache_key = f"rate:{from_currency}:{to_currency}"
        cached_rate = self.redis.get(cache_key)
        if cached_rate:
            return Decimal(cached_rate.decode('utf-8'))

        # Check database cache
        with self.db.cursor(cursor_factory=RealDictCursor) as cur:
            cur.execute("""
                SELECT rate, expires_at FROM exchange_rates_cache
                WHERE base_currency = %s AND target_currency = %s
                AND expires_at > NOW()
                ORDER BY fetched_at DESC LIMIT 1
            """, (from_currency, to_currency))
            db_rate = cur.fetchone()

        if db_rate:
            rate = Decimal(str(db_rate['rate']))
            ttl = int((db_rate['expires_at'] - datetime.utcnow()).total_seconds())
            self.redis.setex(cache_key, ttl, str(rate))
            return rate

        # Fetch from external API
        rate = self._fetch_rate_from_api(from_currency, to_currency)

        # Store in both caches
        expires_at = datetime.utcnow() + timedelta(seconds=self.rate_cache_ttl)
        with self.db.cursor() as cur:
            cur.execute("""
                INSERT INTO exchange_rates_cache
                (base_currency, target_currency, rate, source, expires_at)
                VALUES (%s, %s, %s, %s, %s)
                ON CONFLICT (base_currency, target_currency, source)
                DO UPDATE SET rate = EXCLUDED.rate,
                              fetched_at = CURRENT_TIMESTAMP,
                              expires_at = EXCLUDED.expires_at
            """, (from_currency, to_currency, float(rate), 'unirate_api', expires_at))
            self.db.commit()

        self.redis.setex(cache_key, self.rate_cache_ttl, str(rate))
        return rate

    def _fetch_rate_from_api(self, from_currency: str, to_currency: str) -> Decimal:
        """Fetch exchange rate from external API."""
        try:
            response = requests.get(
                f"https://api.unirateapi.com/v1/latest/{from_currency}",
                params={'api_key': self.api_key},
                timeout=3
            )
            response.raise_for_status()
            data = response.json()

            if to_currency not in data['rates']:
                raise ValueError(f"Currency {to_currency} not found")

            return Decimal(str(data['rates'][to_currency]))

        except Exception as e:
            raise RuntimeError(f"Failed to fetch rate: {e}")

    def _round_to_currency(self, amount: Decimal, currency: str) -> Decimal:
        """Round amount according to currency decimal places."""
        decimal_places = {
            'JPY': 0, 'KRW': 0, 'VND': 0,
            'BHD': 3, 'JOD': 3, 'KWD': 3
        }.get(currency, 2)

        quantize_value = Decimal('0.1') ** decimal_places
        return amount.quantize(quantize_value)


# Flask routes
@app.route('/v1/products//price', methods=['GET'])
def get_product_price(sku):
    """Get product price in specified currency."""
    currency = request.args.get('currency', 'USD').upper()
    country = request.args.get('country', '').upper() or None

    try:
        price_data = pricing_service.get_product_price(sku, currency, country)
        return jsonify(price_data), 200
    except ValueError as e:
        return jsonify({'error': str(e)}), 404
    except Exception as e:
        return jsonify({'error': 'Internal server error'}), 500


@app.route('/v1/products/prices', methods=['POST'])
def get_bulk_prices():
    """Get prices for multiple products."""
    data = request.get_json()
    skus = data.get('skus', [])
    currency = data.get('currency', 'USD').upper()
    country = data.get('country', '').upper() or None

    prices = []
    for sku in skus[:100]:  # Limit to 100 products
        try:
            price_data = pricing_service.get_product_price(sku, currency, country)
            prices.append({
                'sku': sku,
                'price': price_data['price'],
                'currency': currency
            })
        except:
            continue

    return jsonify({'prices': prices, 'count': len(prices)}), 200

4. Caching Strategies for Performance

Multi-Tier Caching Architecture

High-performance pricing systems require intelligent caching at multiple levels:

Redis Cache Implementation

import redis
from functools import wraps
import json

class RedisCacheManager:
    """
    Smart caching manager with automatic invalidation.
    """

    def __init__(self, redis_client):
        self.redis = redis_client

    def cache_exchange_rate(self, from_curr: str, to_curr: str,
                           rate: Decimal, ttl: int = 3600):
        """Cache exchange rate with automatic expiry."""
        key = f"rate:{from_curr}:{to_curr}"
        self.redis.setex(key, ttl, str(rate))

        # Also cache reverse rate
        reverse_key = f"rate:{to_curr}:{from_curr}"
        reverse_rate = 1 / rate
        self.redis.setex(reverse_key, ttl, str(reverse_rate))

    def cache_product_price(self, sku: str, currency: str,
                           price_data: dict, ttl: int = 300):
        """Cache product price with metadata."""
        key = f"price:{sku}:{currency}"
        self.redis.setex(key, ttl, json.dumps(price_data))

    def invalidate_product_prices(self, sku: str):
        """Invalidate all cached prices for a product."""
        pattern = f"price:{sku}:*"
        for key in self.redis.scan_iter(match=pattern):
            self.redis.delete(key)

    def cache_decorator(self, key_pattern: str, ttl: int = 300):
        """Decorator for automatic caching."""
        def decorator(func):
            @wraps(func)
            def wrapper(*args, **kwargs):
                # Generate cache key from function arguments
                cache_key = key_pattern.format(*args, **kwargs)

                # Check cache
                cached = self.redis.get(cache_key)
                if cached:
                    return json.loads(cached.decode('utf-8'))

                # Execute function
                result = func(*args, **kwargs)

                # Store in cache
                self.redis.setex(cache_key, ttl, json.dumps(result))
                return result

            return wrapper
        return decorator


# Usage example
cache_manager = RedisCacheManager(redis_client)

@cache_manager.cache_decorator("bulk_prices:{0}:{1}", ttl=300)
def get_bulk_prices(skus: list, currency: str):
    """Cached bulk price lookup."""
    # Expensive operation here
    return fetch_prices_from_db(skus, currency)

5. Real-Time Price Updates

WebSocket Price Streaming

For real-time applications (trading platforms, live inventory), implement WebSocket-based price updates:

// Frontend WebSocket client
class PriceStreamClient {
    constructor(apiUrl) {
        this.ws = new WebSocket(apiUrl);
        this.subscriptions = new Map();

        this.ws.onmessage = (event) => {
            const data = JSON.parse(event.data);
            this.handlePriceUpdate(data);
        };
    }

    subscribeToPrices(skus, currency) {
        const subscription = {
            action: 'subscribe',
            skus: skus,
            currency: currency
        };

        this.ws.send(JSON.stringify(subscription));

        skus.forEach(sku => {
            this.subscriptions.set(`${sku}:${currency}`, true);
        });
    }

    handlePriceUpdate(data) {
        if (data.type === 'price_update') {
            console.log(`Price update: ${data.sku} = ${data.price} ${data.currency}`);

            // Update UI
            const priceElement = document.getElementById(`price-${data.sku}`);
            if (priceElement) {
                priceElement.textContent = this.formatPrice(data.price, data.currency);
                priceElement.classList.add('price-flash');
            }
        }
    }

    formatPrice(amount, currency) {
        return new Intl.NumberFormat('en-US', {
            style: 'currency',
            currency: currency
        }).format(amount);
    }
}

// Usage
const priceClient = new PriceStreamClient('wss://api.example.com/prices/stream');
priceClient.subscribeToPrices(['PROD-001', 'PROD-002'], 'EUR');

Background Rate Update Worker

import schedule
import time
from datetime import datetime

class RateUpdateWorker:
    """
    Background worker to refresh exchange rates periodically.
    """

    def __init__(self, pricing_service):
        self.pricing_service = pricing_service
        self.major_currencies = ['EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CHF']

    def update_all_rates(self):
        """Update all major currency pairs."""
        print(f"[{datetime.utcnow()}] Starting rate update...")

        updated_count = 0
        for target_currency in self.major_currencies:
            try:
                rate = self.pricing_service.get_exchange_rate('USD', target_currency)
                print(f"  USD/{target_currency}: {rate}")
                updated_count += 1
            except Exception as e:
                print(f"  Error updating {target_currency}: {e}")

        print(f"Updated {updated_count} exchange rates")

        # Trigger price recalculation for dynamic products
        self.recalculate_dynamic_prices()

    def recalculate_dynamic_prices(self):
        """Recalculate all products with dynamic pricing."""
        # Invalidate caches to force fresh calculations
        pattern = "price:*:*"
        for key in self.pricing_service.redis.scan_iter(match=pattern):
            self.pricing_service.redis.delete(key)

        print("Invalidated price caches for dynamic recalculation")

    def start(self):
        """Start the background worker."""
        # Update rates every 15 minutes
        schedule.every(15).minutes.do(self.update_all_rates)

        # Initial update
        self.update_all_rates()

        while True:
            schedule.run_pending()
            time.sleep(60)


# Run worker in separate process
if __name__ == "__main__":
    worker = RateUpdateWorker(pricing_service)
    worker.start()

6. Scaling Considerations

Handling High Traffic

At scale (10,000+ requests/second), implement these optimizations:

• Connection Pooling: Maintain 50-100 persistent connections to your database and Redis
• Horizontal Scaling: Run multiple API server instances behind a load balancer
• Read Replicas: Use database read replicas for price lookups (95% of traffic)
• Rate Limiting: Prevent abuse with per-client API rate limits (100 requests/minute)
• Response Compression: Enable gzip compression for 70% bandwidth reduction
• Batch Operations: Allow clients to request 100 products in one API call

7. Full Implementation Example

Complete E-Commerce Integration

// React component for multi-currency product page
import React, { useState, useEffect } from 'react';

const ProductPage = ({ sku }) => {
    const [price, setPrice] = useState(null);
    const [currency, setCurrency] = useState('USD');
    const [loading, setLoading] = useState(true);

    // Detect user's currency from location
    useEffect(() => {
        const detectCurrency = async () => {
            try {
                const response = await fetch('https://api.ipapi.com/check?access_key=YOUR_KEY');
                const data = await response.json();

                const currencyMap = {
                    'US': 'USD', 'GB': 'GBP', 'DE': 'EUR',
                    'FR': 'EUR', 'JP': 'JPY', 'CA': 'CAD'
                };

                setCurrency(currencyMap[data.country_code] || 'USD');
            } catch (error) {
                console.error('Currency detection failed:', error);
            }
        };

        detectCurrency();
    }, []);

    // Fetch price when currency changes
    useEffect(() => {
        const fetchPrice = async () => {
            setLoading(true);

            try {
                const response = await fetch(
                    `/api/v1/products/${sku}/price?currency=${currency}`
                );
                const data = await response.json();
                setPrice(data);
            } catch (error) {
                console.error('Failed to fetch price:', error);
            } finally {
                setLoading(false);
            }
        };

        fetchPrice();
    }, [sku, currency]);

    const formatPrice = (amount, curr) => {
        return new Intl.NumberFormat('en-US', {
            style: 'currency',
            currency: curr
        }).format(amount);
    };

    return (
        

            

                Currency: 
                 setCurrency(e.target.value)}
                >
                    USD - US Dollar
                    EUR - Euro
                    GBP - British Pound
                    JPY - Japanese Yen
                
            

            

                {loading ? (
                    Loading price...
                ) : price ? (
                    <>
                        
                            {formatPrice(price.price, price.currency)}
                        

                        {price.pricing_type === 'regional_override' && (
                            Regional Pricing
                        )}

                        

                            {price.base_currency !== price.currency && (
                                
                                    Base price: {formatPrice(price.base_price, price.base_currency)}
                                    {' '}(Rate: {price.exchange_rate})
                                
                            )}
                        
                    
                ) : (
                    Price not available
                )}
            
        
    );
};

export default ProductPage;

8. Best Practices & Gotchas

Conclusion

Building a production-ready multi-currency pricing system requires careful architecture across database design, API integration, caching strategies, and real-time updates. The key takeaways:

• Choose the right pricing model (dynamic, fixed, or hybrid) for your business
• Design your database schema to support both conversion and regional overrides
• Implement multi-tier caching (application, Redis, database) for sub-20ms response times
• Use proper decimal types and respect ISO 4217 minor units
• Build fallback mechanisms for API failures to maintain uptime
• Monitor exchange rate accuracy and system performance continuously

With these patterns, you can build a pricing system that scales to millions of products, handles thousands of requests per second, and provides accurate prices across 160+ currencies. Start simple with dynamic conversion, then add regional pricing as your business grows globally.

Related Articles