การชำระเงินแบบหลายสกุลเงิน

ยอมรับการชำระเงินจากลูกค้าทั่วโลกในสกุลเงินท้องถิ่นของพวกเขาขณะที่ได้รับการจ่ายในสกุลเงินที่ต้องการ

ภาพรวม

การสนับสนุนหลายสกุลเงินช่วยให้คุณสามารถคิดค่าธรรมเนียมลูกค้าในสกุลเงินท้องถิ่น (สกุลเงินแสดงผล) ขณะที่ได้รับเงินในสกุลเงินการจ่ายของคุณ ซึ่งช่วยปรับปรุงอัตราการแปลงค่าและให้ความโปร่งใสแก่ลูกค้าระหว่างประเทศ

ประโยชน์หลัก:

• 💰 อัตราการแปลงค่าที่ดีขึ้น - ลูกค้าเห็นราคาในสกุลเงินที่คุ้นเคย
• 🌍 การเข้าถึงแบบโลก - ยอมรับการชำระเงินจากทั่วโลก
• 💱 การแปลงอัตโนมัติ - ใช้อัตราแลกเปลี่ยนแบบเรียลไทม์
• 📊 ราคาที่โปร่งใส - ไม่มีอัตราแลกเปลี่ยนที่ไม่คาดคิดสำหรับลูกค้า
• 🏦 การจ่ายครั้งเดียว - รับเงินทั้งหมดในสกุลเงินเดียว

สกุลเงินที่รองรับ

สกุลเงินแสดงผล（คิดค่าธรรมเนียมลูกค้า)

• THB - บาทไทย
• SGD - ดอลลาร์สิงคโปร์
• MYR - ริงกิตมาเลเซีย
• JPY - เยนญี่ปุ่น
• USD - ดอลลาร์สหรัฐ
• EUR - ยูโร
• GBP - ปอนด์สเตอร์ลิง
• AUD - ดอลลาร์ออสเตรเลีย
• HKD - ดอลลาร์ฮ่องกง
• KRW - วอนเกาหลี
• IDR - รูเปียห์อินโดนีเซีย
• PHP - เปโซฟิลิปปินส์
• CNY - หยวนจีน

และ 100+ สกุลเงินอื่นเพื่อการชำระเงินด้วยบัตร

สกุลเงินการจ่าย（รับเงิน)

สกุลเงินการจ่ายของคุณขึ้นอยู่กับข้อตกลงตัวแทนจำหน่าย:

• THB （ตัวแทนจำหน่ายไทย）
• SGD （ตัวแทนจำหน่ายสิงคโปร์）
• MYR （ตัวแทนจำหน่ายมาเลเซีย）
• JPY （ตัวแทนจำหน่ายญี่ปุ่น）
• USD （ตัวแทนจำหน่ายระหว่างประเทศ）

วิธีการทำงาน

ตัวอย่างการไหล:

1. ตัวแทนจำหน่ายแสดงราคาเป็น USD ให้กับลูกค้าสหรัฐ
2. ลูกค้าชำระเงิน $100 USD
3. Omise แปลงค่าในอัตราแลกเปลี่ยนปัจจุบัน (เช่น 1 USD = 35 THB)
4. ตัวแทนจำหน่ายได้รับ ฿3,500 THB ในการจ่าย

การดำเนินการ

การชาร์จหลายสกุลเงินพื้นฐาน

Node.js

const omise = require('omise')({
    secretKey: 'skey_test_YOUR_SECRET_KEY'
});

// คิดค่าธรรมเนียมลูกค้าในสกุลเงินท้องถิ่น
const charge = await omise.charges.create({
    amount: 10000,      // $100.00 USD
    currency: 'USD',    // สกุลเงินแสดงผล
    card: cardToken,
    description: 'Order #12345'
});

// คุณจะได้รับการจ่ายในสกุลเงินของคุณ (เช่น THB)
console.log('ลูกค้าที่ถูกคิดค่าธรรมเนียม:', charge.amount, charge.currency);
// การจ่ายจะเป็น THB ตามอัตราแลกเปลี่ยน

PHP

<?php
$charge = OmiseCharge::create(array(
    'amount' => 10000,
    'currency' => 'USD',
    'card' => $cardToken,
    'description' => 'Order #12345'
));

// ลูกค้าถูกคิดค่าธรรมเนียมเป็น USD คุณได้รับ THB
?>

Python

import omise

charge = omise.Charge.create(
    amount=10000,
    currency='USD',
    card=card_token,
    description='Order #12345'
)

# ลูกค้าถูกคิดค่าธรรมเนียมเป็น USD คุณได้รับ THB

การเลือกสกุลเงินแบบไดนามิก

// ตรวจจับตำแหน่งของลูกค้าและแสดงสกุลเงินที่เหมาะสม
const customerCurrency = detectCustomerCurrency(req.headers);

const prices = {
    USD: { amount: 10000, symbol: '$', display: '$100.00' },
    EUR: { amount: 9000, symbol: '€', display: '€90.00' },
    GBP: { amount: 8000, symbol: '£', display: '£80.00' },
    THB: { amount: 350000, symbol: '฿', display: '฿3,500' }
};

const price = prices[customerCurrency] || prices.USD;

// แสดงให้ลูกค้า
showPrice(price.display);

// คิดค่าธรรมเนียมในสกุลเงินของลูกค้า
const charge = await omise.charges.create({
    amount: price.amount,
    currency: customerCurrency,
    card: cardToken
});

การตรวจจับสกุลเงิน

โดย IP Geolocation

const geoip = require('geoip-lite');

function detectCustomerCurrency(ipAddress) {
    const geo = geoip.lookup(ipAddress);

    if (!geo) return 'USD'; // ค่าเริ่มต้น

    const currencyMap = {
        'TH': 'THB',
        'SG': 'SGD',
        'MY': 'MYR',
        'JP': 'JPY',
        'US': 'USD',
        'GB': 'GBP',
        'AU': 'AUD'
        // เพิ่มประเทศอื่น
    };

    return currencyMap[geo.country] || 'USD';
}

// การใช้
const currency = detectCustomerCurrency(req.ip);

ตามภาษาเบราว์เซอร์

function detectCurrencyByLanguage(acceptLanguage) {
    const langCurrencyMap = {
        'th': 'THB',
        'en-SG': 'SGD',
        'ms': 'MYR',
        'ja': 'JPY',
        'en-US': 'USD',
        'en-GB': 'GBP'
    };

    // วิเคราะห์ส่วนหัว Accept-Language
    const primaryLang = acceptLanguage.split(',')[0].split(';')[0];
    return langCurrencyMap[primaryLang] || 'USD';
}

ตัวเลือกสกุลเงินแบบแมนนวล

<div class="currency-selector">
    <label>สกุลเงิน:</label>
    <select id="currency" onchange="updatePrices()">
        <option value="USD" selected>USD ($)</option>
        <option value="EUR">EUR (€)</option>
        <option value="GBP">GBP (£)</option>
        <option value="THB">THB (฿)</option>
        <option value="SGD">SGD ($)</option>
        <option value="MYR">MYR (RM)</option>
        <option value="JPY">JPY (¥)</option>
    </select>
</div>

<script>
function updatePrices() {
    const currency = document.getElementById('currency').value;
    const basePrice = 100; // USD

    // ดึงอัตราแลกเปลี่ยนปัจจุบัน
    fetch(`/api/convert?from=USD&to=${currency}&amount=${basePrice}`)
        .then(r => r.json())
        .then(data => {
            document.querySelectorAll('.price').forEach(el => {
                el.textContent = formatCurrency(data.amount, currency);
            });
        });
}
</script>

อัตราแลกเปลี่ยน

Omise ใช้อัตราประมาณ 2-4% สูงกว่าอัตราตลาดกลางรายวัน อัตราถูกกำหนด ณ เวลาทำธุรกรรมและไม่สามารถล็อคล่วงหน้าได้

สำคัญ: ธนาคารผู้ออกบัตรของผู้ถือบัตรใช้อัตราแลกเปลี่ยนของตนเอง ซึ่งอาจสูงกว่าอัตราของ Omise อย่างมาก ในธุรกรรมที่มีมูลค่าสูง ความแตกต่างอาจอยู่ที่ ฿2,000-3,000 หรือมากกว่า

อัตราปัจจุบัน

// ดึงอัตราแลกเปลี่ยนปัจจุบัน
app.get('/api/exchange-rate', async (req, res) => {
    const { from, to } = req.query;

    // Omise ให้บริการอัตราแลกเปลี่ยนผ่าน API
    const rate = await omise.forexRates.retrieve({
        from: from,
        to: to
    });

    res.json({
        from: rate.from,
        to: rate.to,
        rate: rate.rate,
        updated_at: rate.updated_at
    });
});

การแปลงราคา

function convertPrice(amount, fromCurrency, toCurrency, fxRate) {
    if (fromCurrency === toCurrency) {
        return amount;
    }

    const converted = Math.round(amount * fxRate);
    return converted;
}

// การใช้
const usdAmount = 10000; // $100.00
const thbAmount = convertPrice(usdAmount, 'USD', 'THB', 35);
// คืน ฿3,500

ตัวอย่างที่สมบูรณ์

const express = require('express');
const omise = require('omise')({
    secretKey: process.env.OMISE_SECRET_KEY
});

const app = express();
app.use(express.json());

// ราคาพื้นฐานเป็น USD
const PRODUCTS = {
    'product-1': { name: 'Product 1', price_usd: 10000 },
    'product-2': { name: 'Product 2', price_usd: 25000 }
};

// อัตราแลกเปลี่ยน (แคชสิ่งนี้ อัปเดตทุก ๆ ชั่วโมง)
let fxRates = {
    EUR: 0.92,
    GBP: 0.79,
    THB: 35.00,
    SGD: 1.35,
    JPY: 149.50
};

// รับราคาผลิตภัณฑ์ในสกุลเงินลูกค้า
app.get('/api/products/:id/price', (req, res) => {
    const product = PRODUCTS[req.params.id];
    const currency = req.query.currency || 'USD';

    if (!product) {
        return res.status(404).json({ error: 'Product not found' });
    }

    let amount = product.price_usd;

    if (currency !== 'USD') {
        const rate = fxRates[currency];
        if (rate) {
            amount = Math.round(amount * rate);
        }
    }

    res.json({
        product_id: req.params.id,
        name: product.name,
        amount: amount,
        currency: currency,
        formatted: formatCurrency(amount, currency)
    });
});

// สร้างการชาร์จในสกุลเงินลูกค้า
app.post('/checkout', async (req, res) => {
    try {
        const { product_id, currency, token } = req.body;
        const product = PRODUCTS[product_id];

        // คำนวณจำนวนเงินในสกุลเงินลูกค้า
        let amount = product.price_usd;
        if (currency !== 'USD' && fxRates[currency]) {
            amount = Math.round(amount * fxRates[currency]);
        }

        // สร้างการชาร์จ
        const charge = await omise.charges.create({
            amount: amount,
            currency: currency || 'USD',
            card: token,
            description: `${product.name} - ${product_id}`,
            metadata: {
                product_id: product_id,
                original_currency: 'USD',
                original_amount: product.price_usd
            }
        });

        res.json({
            charge_id: charge.id,
            status: charge.status,
            amount: charge.amount,
            currency: charge.currency
        });

    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

// อัปเดตอัตราแลกเปลี่ยนเป็นระยะ ๆ
setInterval(async () => {
    try {
        // ดึงอัตราล่าสุดจาก Omise หรือผู้ให้บริการภายนอก
        const rates = await fetchLatestRates();
        fxRates = rates;
    } catch (error) {
        console.error('Failed to update FX rates:', error);
    }
}, 60 * 60 * 1000); // ทุก ๆ ชั่วโมง

app.listen(3000);

การจัดรูปแบบสกุลเงิน

function formatCurrency(amount, currency) {
    // จำนวนเงินอยู่ในหน่วยสกุลเงินที่เล็กที่สุด
    const divisors = {
        JPY: 1,    // เยนไม่มีทศนิยม
        KRW: 1,    // วอนไม่มีทศนิยม
        THB: 100,  // ทศนิยม 2 ตำแหน่ง
        USD: 100,  // ทศนิยม 2 ตำแหน่ง
        EUR: 100,  // ทศนิยม 2 ตำแหน่ง
        GBP: 100   // ทศนิยม 2 ตำแหน่ง
    };

    const divisor = divisors[currency] || 100;
    const value = amount / divisor;

    return new Intl.NumberFormat('en-US', {
        style: 'currency',
        currency: currency,
        minimumFractionDigits: divisor === 1 ? 0 : 2,
        maximumFractionDigits: divisor === 1 ? 0 : 2
    }).format(value);
}

// การใช้
formatCurrency(10000, 'USD');  // "$100.00"
formatCurrency(350000, 'THB'); // "฿3,500.00"
formatCurrency(10000, 'JPY');  // "¥10,000"

วิธีการที่ดีที่สุด

1. แสดงราคารวมอย่างชัดเจน

<div class="price-breakdown">
    <div class="item-price">
        <span>ราคาสินค้า:</span>
        <span id="item-price">$100.00 USD</span>
    </div>
    <div class="total-price">
        <span>รวม:</span>
        <strong id="total-price">$100.00 USD</strong>
    </div>
    <p class="settlement-note">
        <small>คิดค่าธรรมเนียมเป็น USD อัตราแลกเปลี่ยนนำไปใช้ในขณะที่ซื้อ</small>
    </p>
</div>

2. แคชอัตราแลกเปลี่ยน

// อย่าดึงอัตราในทุก ๆ การขอ
// แคชเป็นเวลา 1 ชั่วโมงและอัปเดตเป็นระยะ ๆ
const cache = new Map();
const CACHE_TTL = 60 * 60 * 1000; // 1 ชั่วโมง

async function getCachedRate(from, to) {
    const key = `${from}-${to}`;
    const cached = cache.get(key);

    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
        return cached.rate;
    }

    const rate = await fetchRateFromAPI(from, to);
    cache.set(key, { rate, timestamp: Date.now() });
    return rate;
}

3. จัดการสกุลเงินที่มีศูนย์ทศนิยม

// JPY, KRW ไม่มีทศนิยม
const zeroDecimalCurrencies = ['JPY', 'KRW', 'VND', 'CLP'];

function getAmountForCurrency(baseAmount, currency) {
    if (zeroDecimalCurrencies.includes(currency)) {
        return baseAmount; // ไม่คูณ 100
    }
    return baseAmount * 100; // สำหรับสกุลเงินที่มีทศนิยม
}

4. แสดงสัญลักษณ์สกุลเงิน

const currencySymbols = {
    USD: '$',
    EUR: '€',
    GBP: '£',
    THB: '฿',
    SGD: 'S$',
    MYR: 'RM',
    JPY: '¥',
    KRW: '₩'
};

function formatPrice(amount, currency) {
    const symbol = currencySymbols[currency] || currency;
    return `${symbol}${amount}`;
}

5. ทดสอบกับสกุลเงินหลาย ๆ สกุล

ทดสอบการไหลการชำระเงินพร้อมกับ:

• USD (มาตรฐาน)
• EUR (สกุลเงินระหว่างประเทศทั่วไป)
• JPY (ศูนย์ทศนิยม)
• THB (สกุลเงินการจ่ายแตกต่างหากจำเป็น)

คำถามที่พบบ่อย

ใช้อัตราแลกเปลี่ยนใด?

Omise ใช้อัตราแลกเปลี่ยนตลาดแบบเรียลไทม์จากสถาบันการเงินหลัก อัตราจะอัปเดตบ่อยครั้งตลอดทั้งวัน

ใครรับความเสี่ยงด้านอัตราแลกเปลี่ยน?

ตัวแทนจำหน่ายรับความเสี่ยงด้านอัตราแลกเปลี่ยน หากอัตราเปลี่ยนแปลงระหว่างการชาร์จและการจ่าย จำนวนเงินที่จ่ายอาจแตกต่างกันเล็กน้อย

ฉันสามารถกำหนดอัตราแลกเปลี่ยนของตัวเองได้หรือไม่?

ไม่ได้ Omise ใช้อัตราตลาดโดยอัตโนมัติ คุณสามารถเพิ่มมาร์จิ่นให้กับราคาของคุณได้หากต้องการ แต่ไม่สามารถ กำหนดอัตราแลกเปลี่ยนได้

ฉันได้รับเงินในสกุลเงินใด?

คุณจะได้รับเงินในสกุลเงินการจ่ายของคุณ (โดยทั่วไปตามประเทศตัวแทนจำหน่าย - THB สำหรับไทย SGD สำหรับสิงคโปร์ เป็นต้น)

ลูกค้าสามารถเลือกสกุลเงินได้หรือไม่?

ใช่ คุณสามารถใช้ตัวเลือกสกุลเงิน แต่การแสดงราคาในสกุลเงินท้องถิ่นของลูกค้าโดยอัตโนมัติ (ตามตำแหน่ง) มักจะเพิ่มอัตราการแปลงค่า

แหล่งข้อมูลที่เกี่ยวข้อง

• การชาร์จการ์ด - พื้นฐานการชำระเงินด้วยการ์ด
• การทดสอบ - ทดสอบหลายสกุลเงิน
• การคืนเงิน - การคืนเงินแบบหลายสกุลเงิน

ขั้นตอนถัดไป

1. กำหนดสกุลเงินที่จะสนับสนุน
2. ใช้การตรวจจับสกุลเงิน
3. เพิ่มตัวเลือกสกุลเงิน (ไม่บังคับ)
4. ทดสอบกับสกุลเงินหลาย ๆ สกุล
5. ตรวจสอบอัตราแลกเปลี่ยนและการจ่าย
6. เข้าสู่โหมดจริง