Shopify Multi-Currency Integration: Complete API Guide for Global E-commerce

// 1. Sign up at currency-exchange.app
// 2. Navigate to Settings → API Keys
// 3. Create new API key with scopes:
//    - rates:read (for fetching exchange rates)
//    - conversions:write (for price conversions)

// Store credentials securely in environment variables
// .env file
CURRENCY_EXCHANGE_API_KEY=sk_live_xxxxxxxxx
CURRENCY_EXCHANGE_API_URL=https://currency-exchange.app/api/v1
SHOPIFY_STORE_URL=https://your-store.myshopify.com
SHOPIFY_ACCESS_TOKEN=shpat_xxxxxxxxx

# Install Shopify CLI
npm install -g @shopify/cli@latest

# Create new app
shopify app init currency-integration

# Configure required scopes in shopify.app.toml
scopes = "write_products,write_price_rules,write_locales,read_locales"

# Install dependencies
cd currency-integration
npm install @shopify/admin-api-client @any-xyz/module-any-xyz-api-sdk-js

// webhooks/product-update.js
import { Api } from '@any-xyz/module-any-xyz-api-sdk-js';
import { shopifyAdminClient } from '../lib/shopify-client';

// Initialize Currency-Exchange.app client
const currencyClient = new Api({
  baseURL: process.env.CURRENCY_EXCHANGE_API_URL,
  headers: {
    'X-API-Key': process.env.CURRENCY_EXCHANGE_API_KEY,
  },
  timeout: 50000,
});

export async function productUpdateHandler(event) {
  const { id, variants } = event.data.object;

  // Get supported currencies for your store
  const targetCurrencies = [
    'GBP', 'EUR', 'CAD', 'AUD', 'JPY',
    // Add all your target markets
  ];

  // Fetch real-time rates for USD base
  const { data: rates } = await currencyClient.v1GetRates
    .v1GetRatesAction({
      base: 'USD',
    });

  // Convert each variant price to all target currencies
  for (const variant of variants) {
    const basePrice = parseFloat(variant.price);

    for (const currency of targetCurrencies) {
      const rate = rates.quotes[`USD${currency}`];
      const convertedPrice = basePrice * rate;

      // Update Shopify variant with local price
      await shopifyAdminClient.request(
        UPDATE_PRODUCT_VARIANT_PRICE,
        {
          variables: {
            id: variant.admin_graphql_api_id,
            price: convertedPrice.toFixed(2),
            currencyCode: currency,
          },
        }
      );
    }
  }

  return { success: true };
}

// GraphQL mutation for updating prices
const UPDATE_PRODUCT_VARIANT_PRICE = `#graphql
  mutation updateVariantPrice($id: ID!, $price: String!, $currencyCode: CurrencyCode!) {
    productVariantUpdate(
      input: {
        id: $id
        price: $price
        currencyCode: $currencyCode
      }
    ) {
      productVariant {
        id
        price
        currencyCode
      }
      userErrors {
        field
        message
      }
    }
  }
`;

// Configure Shopify Markets with API prices
import { shopifyAdminClient } from '../lib/shopify-client';

async function configureMarkets() {
  const { data } = await shopifyAdminClient.request(
    CONFIGURE_MARKETS,
    {
      variables: {
        input: {
          // United Kingdom market
          marketId: 'gid://shopify/Market/1',
          enabled: true,
          pricingStrategy: {
            type: 'MANUAL',
            // Use API-converted prices instead of auto-conversion
          },
          currencyCode: 'GBP',
          languages: ['en'],
        },
      },
    }
  );

  return data.marketUpdate;
}

const CONFIGURE_MARKETS = `#graphql
  mutation marketUpdate($input: MarketUpdateInput!) {
    marketUpdate(input: $input) {
      market {
        id
        name
        enabled
        currencies {
          isoCode
        }
      }
      userErrors {
        field
        message
      }
    }
  }
`;

// Configure all markets
const markets = [
  { id: '1', currency: 'GBP', name: 'United Kingdom' },
  { id: '2', currency: 'EUR', name: 'European Union' },
  { id: '3', currency: 'CAD', name: 'Canada' },
  { id: '4', currency: 'AUD', name: 'Australia' },
  // Add more markets
];

for (const market of markets) {
  await configureMarkets(market);
}

// snippets/currency-switcher.liquid
<div class='currency-switcher' id='currency-switcher'>
  <label for='currency-select'>Currency:</label>
  <select id='currency-select' onchange='updateCurrency(this.value)'>
    <option value='USD' {{ shop.currency == 'USD' ? 'selected' : '' }}>
      $ USD
    </option>
    <option value='GBP' {{ shop.currency == 'GBP' ? 'selected' : '' }}>
      £ GBP
    </option>
    <option value='EUR' {{ shop.currency == 'EUR' ? 'selected' : '' }}>
      € EUR
    </option>
    <option value='CAD' {{ shop.currency == 'CAD' ? 'selected' : '' }}>
      $ CAD
    </option>
    <option value='AUD' {{ shop.currency == 'AUD' ? 'selected' : '' }}>
      $ AUD
    </option>
    <!-- Add more currencies -->
  </select>
</div>

<script>
async function updateCurrency(currency) {
  // Update Shopify session currency
  await fetch('/localization/update', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      currency: currency,
      _method: 'PUT'
    })
  });

  // Reload page to show prices in new currency
  window.location.reload();
}
</script>

<style>
.currency-switcher {
  display: flex;
  align-items: center;
  gap: 0.5rem;
  padding: 0.5rem 1rem;
  border: 1px solid #e5e7eb;
  border-radius: 0.375rem;
}

#currency-select {
  padding: 0.25rem 0.5rem;
  border: 1px solid #d1d5db;
  border-radius: 0.25rem;
  background: white;
  cursor: pointer;
}
</style>

// app/routes/webhooks/rate-change.ts
import { json, type LoaderFunctionArgs } from '@shopify/remix-oxygen';
import { currencyClient } from '../lib/currency-client';

// Track previous rates to detect significant changes
let previousRates: Record<string, number> = {};

export async function loader({ request }: LoaderFunctionArgs) {
  // Get current rates
  const { data: currentRates } = await currencyClient.v1GetRates.v1GetRatesAction({
    base: 'USD',
  });

  // Check for significant changes (>0.5%)
  const significantChanges: string[] = [];

  for (const [pair, rate] of Object.entries(currentRates.quotes)) {
    const previousRate = previousRates[pair];
    const changePercent = previousRate
      ? ((rate - previousRate) / previousRate) * 100
      : 0;

    if (Math.abs(changePercent) > 0.5) {
      significantChanges.push(`${pair}: ${changePercent.toFixed(2)}%`);
    }

    previousRates[pair] = rate;
  }

  // If significant changes detected, trigger price updates
  if (significantChanges.length > 0) {
    await triggerPriceUpdate();

    // Send notification to store admin
    await sendNotification({
      title: 'Exchange Rate Update',
      message: `Significant rate changes detected:
${significantChanges.join('\n')}`,
    });
  }

  return json({ success: true, changes: significantChanges });
}

async function triggerPriceUpdate() {
  // Queue bulk price update job
  await fetch('/api/jobs/update-prices', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      reason: 'rate_change',
      timestamp: new Date().toISOString(),
    }),
  });
}

// WooCommerce plugin: functions.php

// Add custom currency with API rates
add_filter('woocommerce_currencies', 'add_custom_currencies');
function add_custom_currencies($currencies) {
    $currencies['GBP'] = __('British Pound', 'woocommerce');
    $currencies['EUR'] = __('Euro', 'woocommerce');
    $currencies['CAD'] = __('Canadian Dollar', 'woocommerce');
    // Add more currencies
    return $currencies;
}

// Fetch real-time rates from Currency-Exchange.app
add_filter('woocommerce_get_price', 'custom_currency_conversion', 10, 2);
function custom_currency_conversion($price, $product) {
    $selected_currency = get_woocommerce_currency();

    if ($selected_currency !== 'USD') {
        // Get rate from Currency-Exchange.app API
        $rate = fetch_exchange_rate('USD', $selected_currency);
        $price = $price * $rate;
    }

    return $price;
}

function fetch_exchange_rate($from, $to) {
    $api_key = get_option('currency_exchange_api_key');
    $response = wp_remote_get(
        "https://currency-exchange.app/api/v1/convert?from={$from}&to={$to}&amount=1",
        array(
            'headers' => array(
                'X-API-Key' => $api_key,
            ),
            'timeout' => 50,
        )
    );

    if (!is_wp_error($response)) {
        $body = json_decode(wp_remote_retrieve_body($response), true);
        return $body['result']['rate'];
    }

    return 1.0; // Fallback
}