Building International Payment Features with Exchange Rate APIs

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

function MultiCurrencyCheckout({ basePrice, baseCurrency }) {
  const [selectedCurrency, setSelectedCurrency] = useState('USD');
  const [exchangeRate, setExchangeRate] = useState(null);
  const [convertedPrice, setConvertedPrice] = useState(basePrice);

  useEffect(() => {
    async function fetchRate() {
      try {
        const response = await fetch(
          `https://api.unirateapi.com/v1/convert?from=${baseCurrency}&to=${selectedCurrency}&amount=${basePrice}`,
          {
            headers: {
              'X-API-Key': process.env.REACT_APP_EXCHANGE_API_KEY
            }
          }
        );
        const data = await response.json();

        setExchangeRate(data.rate);
        setConvertedPrice(data.result);
      } catch (error) {
        console.error('Rate fetch failed:', error);
        // Fallback: show only base currency
      }
    }

    if (selectedCurrency !== baseCurrency) {
      fetchRate();
    } else {
      setConvertedPrice(basePrice);
      setExchangeRate(1);
    }
  }, [selectedCurrency, basePrice, baseCurrency]);

  return (
    

      

        Display prices in:
         setSelectedCurrency(e.target.value)}
        >
          USD - US Dollar
          EUR - Euro
          GBP - British Pound
          JPY - Japanese Yen
          AUD - Australian Dollar
        
      

      

        
Total: {convertedPrice.toFixed(2)} {selectedCurrency}
        {selectedCurrency !== baseCurrency && (
          

            Rate: 1 {baseCurrency} = {exchangeRate?.toFixed(4)} {selectedCurrency}
            

            You will be charged {basePrice} {baseCurrency}
          
        )}
      

      
        Pay {basePrice} {baseCurrency}
      
    
  );
}

// Node.js backend for multi-currency payment processing
const express = require('express');
const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);
const axios = require('axios');
const redis = require('redis');

const app = express();
const redisClient = redis.createClient();

// Fetch and cache exchange rate
async function getExchangeRate(from, to) {
  const cacheKey = `rate:${from}:${to}`;

  // Check Redis cache first
  const cached = await redisClient.get(cacheKey);
  if (cached) {
    return JSON.parse(cached);
  }

  // Fetch from exchange rate API
  try {
    const response = await axios.get(
      `https://api.unirateapi.com/v1/standard?from=${from}&to=${to}`,
      {
        headers: {
          'X-API-Key': process.env.EXCHANGE_API_KEY
        }
      }
    );

    const rate = response.data.rate;

    // Cache for 15 minutes
    await redisClient.setex(cacheKey, 900, JSON.stringify(rate));

    return rate;
  } catch (error) {
    console.error('Exchange rate fetch failed:', error);
    throw new Error('Unable to fetch current exchange rate');
  }
}

// Checkout endpoint
app.post('/api/checkout', async (req, res) => {
  const { amount, baseCurrency, targetCurrency, customerEmail } = req.body;

  try {
    let finalAmount = amount;
    let rate = 1;

    // Convert if necessary
    if (baseCurrency !== targetCurrency) {
      rate = await getExchangeRate(baseCurrency, targetCurrency);
      finalAmount = Math.round(amount * rate * 100) / 100;
    }

    // Create Stripe payment intent
    const paymentIntent = await stripe.paymentIntents.create({
      amount: Math.round(finalAmount * 100), // Stripe uses cents
      currency: targetCurrency.toLowerCase(),
      metadata: {
        original_amount: amount,
        original_currency: baseCurrency,
        exchange_rate: rate,
        rate_timestamp: new Date().toISOString()
      },
      receipt_email: customerEmail
    });

    // Store transaction details for future reference/refunds
    await storeTransaction({
      payment_intent_id: paymentIntent.id,
      original_amount: amount,
      original_currency: baseCurrency,
      charged_amount: finalAmount,
      charged_currency: targetCurrency,
      exchange_rate: rate,
      timestamp: new Date()
    });

    res.json({
      clientSecret: paymentIntent.client_secret,
      amount: finalAmount,
      currency: targetCurrency,
      rate: rate
    });
  } catch (error) {
    console.error('Checkout failed:', error);
    res.status(500).json({ error: error.message });
  }
});

async function storeTransaction(data) {
  // Store in your database for refund processing
  // Implementation depends on your database choice
  console.log('Transaction stored:', data);
}

// Complete Stripe checkout with custom rates
const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);
const axios = require('axios');

async function createStripeCheckout(orderData) {
  const { items, customerCurrency, customerEmail } = orderData;

  // Calculate base price in USD
  const baseAmountUSD = items.reduce((sum, item) => sum + item.price, 0);

  // Fetch current exchange rate
  const rateResponse = await axios.get(
    `https://api.unirateapi.com/v1/standard?from=USD&to=${customerCurrency}`,
    {
      headers: { 'X-API-Key': process.env.EXCHANGE_API_KEY }
    }
  );

  const rate = rateResponse.data.rate;

  // Optional: Add transparent 1% markup
  const markup = 1.01;
  const effectiveRate = rate * markup;

  // Calculate final amount
  const convertedAmount = Math.round(baseAmountUSD * effectiveRate * 100) / 100;

  // Create Stripe checkout session
  const session = await stripe.checkout.sessions.create({
    payment_method_types: ['card'],
    line_items: [
      {
        price_data: {
          currency: customerCurrency.toLowerCase(),
          product_data: {
            name: 'Order Total',
            description: `Converted from $${baseAmountUSD.toFixed(2)} USD at rate ${effectiveRate.toFixed(4)}`
          },
          unit_amount: Math.round(convertedAmount * 100)
        },
        quantity: 1
      }
    ],
    mode: 'payment',
    success_url: `${process.env.DOMAIN}/success?session_id={CHECKOUT_SESSION_ID}`,
    cancel_url: `${process.env.DOMAIN}/cancel`,
    customer_email: customerEmail,
    metadata: {
      base_amount_usd: baseAmountUSD,
      exchange_rate: effectiveRate,
      conversion_timestamp: new Date().toISOString(),
      currency_pair: `USD/${customerCurrency}`
    }
  });

  return {
    sessionId: session.id,
    url: session.url,
    amountCharged: convertedAmount,
    currency: customerCurrency,
    exchangeRate: effectiveRate
  };
}

module.exports = { createStripeCheckout };

// PayPal order creation with custom currency conversion
const paypal = require('@paypal/checkout-server-sdk');
const axios = require('axios');

// Configure PayPal client
const environment = new paypal.core.SandboxEnvironment(
  process.env.PAYPAL_CLIENT_ID,
  process.env.PAYPAL_CLIENT_SECRET
);
const client = new paypal.core.PayPalHttpClient(environment);

async function createPayPalOrder(baseAmount, targetCurrency) {
  // Fetch exchange rate
  const rateData = await axios.get(
    `https://api.unirateapi.com/v1/convert?from=USD&to=${targetCurrency}&amount=${baseAmount}`,
    {
      headers: { 'X-API-Key': process.env.EXCHANGE_API_KEY }
    }
  );

  const convertedAmount = rateData.data.result;
  const rate = rateData.data.rate;

  // Create PayPal order request
  const request = new paypal.orders.OrdersCreateRequest();
  request.prefer("return=representation");
  request.requestBody({
    intent: 'CAPTURE',
    purchase_units: [{
      amount: {
        currency_code: targetCurrency,
        value: convertedAmount.toFixed(2),
        breakdown: {
          item_total: {
            currency_code: targetCurrency,
            value: convertedAmount.toFixed(2)
          }
        }
      },
      description: `Converted from ${baseAmount} USD at rate ${rate.toFixed(4)}`
    }],
    application_context: {
      brand_name: 'Your Store Name',
      landing_page: 'BILLING',
      user_action: 'PAY_NOW',
      return_url: `${process.env.DOMAIN}/paypal/success`,
      cancel_url: `${process.env.DOMAIN}/paypal/cancel`
    }
  });

  try {
    const order = await client.execute(request);

    // Store rate information for refund processing
    await storePayPalTransaction({
      order_id: order.result.id,
      base_amount: baseAmount,
      base_currency: 'USD',
      converted_amount: convertedAmount,
      target_currency: targetCurrency,
      exchange_rate: rate,
      timestamp: new Date()
    });

    return {
      orderId: order.result.id,
      approvalUrl: order.result.links.find(link => link.rel === 'approve').href
    };
  } catch (error) {
    console.error('PayPal order creation failed:', error);
    throw error;
  }
}

# Python: Processing refund with historical exchange rate
import requests
from datetime import datetime
from decimal import Decimal

def process_refund(transaction_id, refund_amount):
    """
    Process refund using original transaction exchange rate.
    Falls back to historical API if rate not stored.
    """
    # Fetch original transaction from database
    transaction = get_transaction(transaction_id)

    # Try to use stored exchange rate first
    if transaction.exchange_rate:
        rate = Decimal(transaction.exchange_rate)
    else:
        # Fallback: Fetch historical rate from API
        transaction_date = transaction.created_at.strftime('%Y-%m-%d')

        response = requests.get(
            f'https://api.unirateapi.com/v1/historical',
            params={
                'date': transaction_date,
                'from': transaction.base_currency,
                'to': transaction.charged_currency
            },
            headers={
                'X-API-Key': os.environ['EXCHANGE_API_KEY']
            }
        )

        if response.status_code != 200:
            raise Exception('Unable to fetch historical exchange rate')

        rate = Decimal(response.json()['rate'])

    # Calculate refund amount in charged currency
    refund_in_charged_currency = refund_amount * rate

    # Process refund through payment gateway
    if transaction.payment_method == 'stripe':
        stripe_refund = stripe.Refund.create(
            payment_intent=transaction.payment_intent_id,
            amount=int(refund_in_charged_currency * 100),
            metadata={
                'original_rate': str(rate),
                'base_refund_amount': str(refund_amount),
                'refund_reason': 'customer_request'
            }
        )

        # Update transaction record
        update_transaction_refund(
            transaction_id=transaction_id,
            refund_id=stripe_refund.id,
            refund_amount=refund_in_charged_currency,
            refund_currency=transaction.charged_currency,
            refund_rate=rate
        )

        return {
            'success': True,
            'refund_id': stripe_refund.id,
            'amount_refunded': float(refund_in_charged_currency),
            'currency': transaction.charged_currency,
            'rate_used': float(rate)
        }

    else:
        raise Exception(f'Unsupported payment method: {transaction.payment_method}')


def get_transaction(transaction_id):
    """Fetch transaction from database - implement based on your ORM"""
    # This is a placeholder - implement with your actual database
    pass

def update_transaction_refund(transaction_id, refund_id, refund_amount,
                              refund_currency, refund_rate):
    """Update transaction record with refund details"""
    # Implement based on your database structure
    pass

// Redis-based rate caching with fallback
const redis = require('redis');
const axios = require('axios');

class ExchangeRateCache {
  constructor() {
    this.redis = redis.createClient({
      host: process.env.REDIS_HOST,
      port: process.env.REDIS_PORT,
      retry_strategy: (options) => {
        if (options.error && options.error.code === 'ECONNREFUSED') {
          return new Error('Redis connection refused');
        }
        return Math.min(options.attempt * 100, 3000);
      }
    });

    this.redis.on('error', (err) => {
      console.error('Redis error:', err);
    });
  }

  async getRate(from, to) {
    const cacheKey = `exchange_rate:${from}:${to}`;
    const staleKey = `exchange_rate:${from}:${to}:stale`;

    try {
      // Try to get fresh cached rate
      const cached = await this.redis.get(cacheKey);
      if (cached) {
        return JSON.parse(cached);
      }

      // Cache miss - fetch from API
      const freshRate = await this.fetchFromAPI(from, to);

      // Cache for 15 minutes (fresh)
      await this.redis.setex(
        cacheKey,
        900, // 15 minutes
        JSON.stringify(freshRate)
      );

      // Also cache for 24 hours as stale fallback
      await this.redis.setex(
        staleKey,
        86400, // 24 hours
        JSON.stringify(freshRate)
      );

      return freshRate;

    } catch (error) {
      console.error('Error fetching rate:', error);

      // Try to use stale cache as fallback
      const staleRate = await this.redis.get(staleKey);
      if (staleRate) {
        console.warn('Using stale exchange rate due to API failure');
        return JSON.parse(staleRate);
      }

      // Last resort: throw error
      throw new Error('Unable to fetch exchange rate and no cached value available');
    }
  }

  async fetchFromAPI(from, to) {
    const response = await axios.get(
      `https://api.unirateapi.com/v1/standard`,
      {
        params: { from, to },
        headers: { 'X-API-Key': process.env.EXCHANGE_API_KEY },
        timeout: 5000 // 5 second timeout
      }
    );

    return {
      from,
      to,
      rate: response.data.rate,
      timestamp: new Date().toISOString()
    };
  }

  async clearCache(from, to) {
    const cacheKey = `exchange_rate:${from}:${to}`;
    const staleKey = `${cacheKey}:stale`;

    await this.redis.del([cacheKey, staleKey]);
  }
}

module.exports = ExchangeRateCache;

// Jest test suite for currency conversion logic
const { convertAmount, applyMarkup, roundCurrency } = require('./currency-utils');

describe('Currency Conversion', () => {
  describe('convertAmount', () => {
    it('should convert USD to EUR correctly', () => {
      const result = convertAmount(100, 'USD', 'EUR', 0.92);
      expect(result).toBe(92.00);
    });

    it('should handle very small amounts without precision loss', () => {
      const result = convertAmount(0.01, 'USD', 'JPY', 150.25);
      expect(result).toBe(1.50);
    });

    it('should handle very large amounts', () => {
      const result = convertAmount(1000000, 'USD', 'EUR', 0.92);
      expect(result).toBe(920000.00);
    });

    it('should return original amount when currencies match', () => {
      const result = convertAmount(100, 'USD', 'USD', 1);
      expect(result).toBe(100.00);
    });

    it('should throw error for invalid currencies', () => {
      expect(() => {
        convertAmount(100, 'INVALID', 'USD', 1);
      }).toThrow('Invalid currency code');
    });
  });

  describe('applyMarkup', () => {
    it('should apply 1% markup correctly', () => {
      const rate = applyMarkup(0.92, 0.01);
      expect(rate).toBeCloseTo(0.9292, 4);
    });

    it('should handle zero markup', () => {
      const rate = applyMarkup(0.92, 0);
      expect(rate).toBe(0.92);
    });
  });

  describe('roundCurrency', () => {
    it('should round to 2 decimals for most currencies', () => {
      expect(roundCurrency(92.345, 'USD')).toBe(92.35);
      expect(roundCurrency(92.344, 'EUR')).toBe(92.34);
    });

    it('should round to 0 decimals for JPY', () => {
      expect(roundCurrency(1234.56, 'JPY')).toBe(1235);
    });

    it('should handle negative amounts', () => {
      expect(roundCurrency(-50.789, 'USD')).toBe(-50.79);
    });
  });
});