WeChat Pay UPM

รับชำระเงินหน้าร้านจากผู้ใช้ WeChat Pay โดยสแกนบาร์โค้ดชำระเงินของลูกค้าผ่านระบบ POS

ตัวเลือก WeChat Pay อื่นๆ

สำหรับการชำระเงินออนไลน์ ดูที่ WeChat Pay สำหรับ QR Code ที่ร้านค้าแสดง (C scan B) ดูที่ WeChat Pay MPM

ภาพรวม

WeChat Pay User-Presented Mode (UPM) เป็นวิธีการชำระเงินออฟไลน์ที่ร้านค้าสแกนบาร์โค้ดที่ลูกค้าแสดงในแอป WeChat หรือที่เรียกว่า "B scan C" (Business scans Customer) วิธีนี้เหมาะสำหรับสภาพแวดล้อมค้าปลีกที่มีปริมาณการขายสูง โดยร้านค้ามีเครื่องสแกนบาร์โค้ดที่เครื่อง POS

คุณสมบัติหลัก:

ชำระเงินรวดเร็ว - สแกนและประมวลผลภายในไม่กี่วินาที
ขั้นตอนออฟไลน์ - ไม่ต้อง redirect ชำระเงินผ่านบาร์โค้ด
ฐานผู้ใช้ขนาดใหญ่ - เข้าถึงผู้ใช้ WeChat กว่า 1.3 พันล้านคน
ประสบการณ์ที่คุ้นเคย - คล้ายกับการสแกนบาร์โค้ดสินค้า
ข้ามพรมแดน - รับชำระเงินจากนักท่องเที่ยวจีน
เชื่อมต่อ POS - ใช้งานได้กับเครื่องสแกนบาร์โค้ดที่มีอยู่

ภูมิภาคที่รองรับ

ภูมิภาค	สกุลเงิน	จำนวนขั้นต่ำ	จำนวนสูงสุด	เวอร์ชัน API
ประเทศไทย	THB	20.00	150,000.00	`2017-11-02`

การชำระเงินข้ามพรมแดน

WeChat Pay UPM มีคุณค่าเป็นพิเศษสำหรับร้านค้าที่เจาะกลุ่มนักท่องเที่ยวจีน ลูกค้าชำระเงินเป็น CNY จาก WeChat Wallet และคุณได้รับการชำระเงินเป็น THB

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

ขั้นตอนการชำระเงิน:

ลูกค้าเปิดแอป WeChat บนโทรศัพท์
ลูกค้าไปที่ "Pay" และแสดงบาร์โค้ดชำระเงิน
ร้านค้าสแกนบาร์โค้ดด้วยเครื่อง POS
สร้าง charge ด้วยค่าบาร์โค้ดที่สแกน
ลูกค้ายืนยันการชำระเงินในแอป WeChat (อาจต้องใช้ PIN/ไบโอเมตริก)
การชำระเงินถูกประมวลผลและทั้งสองฝ่ายได้รับการยืนยัน

เวลาที่ใช้ทั่วไป: 10-30 วินาที

การติดตั้งใช้งาน

สร้าง Charge ด้วยบาร์โค้ด

สำหรับ UPM คุณสร้าง charge โดยตรงด้วยค่าบาร์โค้ดที่สแกน ต่างจากวิธีการชำระเงินอื่นๆ ไม่มีขั้นตอนสร้าง source แยกต่างหาก - source จะถูกสร้างพร้อมกับ charge

curl https://api.omise.co/charges \
  -u $OMISE_SECRET_KEY: \
  -d "amount=150000" \
  -d "currency=THB" \
  -d "source[type]=wechat_pay_upm" \
  -d "source[barcode]=130991292552725093"

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

const charge = await omise.charges.create({
    amount: 150000,  // THB 1,500.00
    currency: 'THB',
    source: {
        type: 'wechat_pay_upm',
        barcode: '130991292552725093'  // Scanned from customer's WeChat
    }
});

console.log('Charge status:', charge.status);
console.log('Charge ID:', charge.id);

<?php
$charge = OmiseCharge::create([
    'amount' => 150000,
    'currency' => 'THB',
    'source' => [
        'type' => 'wechat_pay_upm',
        'barcode' => '130991292552725093'
    ]
]);

echo "Status: " . $charge['status'];
echo "Charge ID: " . $charge['id'];
?>

import omise

omise.api_secret = 'skey_test_YOUR_SECRET_KEY'

charge = omise.Charge.create(
    amount=150000,
    currency='THB',
    source={
        'type': 'wechat_pay_upm',
        'barcode': '130991292552725093'
    }
)

print(f"Status: {charge.status}")
print(f"Charge ID: {charge.id}")

require 'omise'

Omise.api_key = 'skey_test_YOUR_SECRET_KEY'

charge = Omise::Charge.create({
  amount: 150000,
  currency: 'THB',
  source: {
    type: 'wechat_pay_upm',
    barcode: '130991292552725093'
  }
})

puts "Status: #{charge.status}"
puts "Charge ID: #{charge.id}"

charge, err := client.Charges().Create(&operations.CreateCharge{
    Amount:   150000,
    Currency: "THB",
    Source: &operations.Source{
        Type:    "wechat_pay_upm",
        Barcode: "130991292552725093",
    },
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Status: %s\n", charge.Status)

Map<String, Object> sourceParams = new HashMap<>();
sourceParams.put("type", "wechat_pay_upm");
sourceParams.put("barcode", "130991292552725093");

Charge charge = client.charges().create(new Charge.CreateParams()
    .amount(150000L)
    .currency("THB")
    .source(sourceParams));

System.out.println("Status: " + charge.getStatus());
System.out.println("Charge ID: " + charge.getId());

var charge = await client.Charges.Create(new CreateChargeRequest
{
    Amount = 150000,
    Currency = "THB",
    Source = new PaymentSource
    {
        Type = "wechat_pay_upm",
        Barcode = "130991292552725093"
    }
});

Console.WriteLine($"Status: {charge.Status}");
Console.WriteLine($"Charge ID: {charge.Id}");

Response:

{
  "object": "charge",
  "id": "chrg_test_5rt6s9vah5lkvi1rh9d",
  "amount": 150000,
  "currency": "THB",
  "status": "pending",
  "source": {
    "object": "source",
    "id": "src_test_5rt6s9vah5lkvi1rh9c",
    "type": "wechat_pay_upm",
    "flow": "offline",
    "barcode": "130991292552725093"
  },
  "created_at": "2024-01-15T10:30:00Z"
}

จัดการ Charge Response

app.post('/pos/wechat-payment', async (req, res) => {
    const { amount, barcode, order_id } = req.body;

    // ตรวจสอบจำนวนเงิน
    if (amount < 2000 || amount > 15000000) {
        return res.status(400).json({
            success: false,
            error: 'Amount must be between 20 and 150,000'
        });
    }

    // ตรวจสอบรูปแบบบาร์โค้ด
    if (!barcode || barcode.length < 10) {
        return res.status(400).json({
            success: false,
            error: 'Invalid barcode'
        });
    }

    try {
        const charge = await omise.charges.create({
            amount: amount,
            currency: 'THB',
            source: {
                type: 'wechat_pay_upm',
                barcode: barcode
            },
            metadata: {
                order_id: order_id,
                pos_terminal: 'POS-001'
            }
        });

        if (charge.status === 'successful') {
            // ชำระเงินสำเร็จทันที
            printReceipt(charge);
            res.json({
                success: true,
                charge_id: charge.id,
                status: 'successful'
            });
        } else if (charge.status === 'pending') {
            // ลูกค้าต้องยืนยันในแอป WeChat
            // รอการแจ้งเตือน webhook
            res.json({
                success: true,
                charge_id: charge.id,
                status: 'pending',
                message: 'Please ask customer to confirm payment in WeChat'
            });
        } else {
            res.json({
                success: false,
                status: charge.status,
                message: charge.failure_message || 'Payment failed'
            });
        }
    } catch (error) {
        console.error('WeChat Pay UPM error:', error);
        res.status(500).json({
            success: false,
            error: error.message
        });
    }
});

จัดการการแจ้งเตือน Webhook

app.post('/webhooks/omise', (req, res) => {
    const event = req.body;

    if (event.key === 'charge.complete') {
        const charge = event.data;

        if (charge.source && charge.source.type === 'wechat_pay_upm') {
            if (charge.status === 'successful') {
                // ยืนยันการชำระเงิน
                notifyPOS(charge.id, 'success');
                updateOrderStatus(charge.metadata.order_id, 'paid');
                console.log(`WeChat Pay UPM successful: ${charge.id}`);
            } else if (charge.status === 'failed') {
                // การชำระเงินล้มเหลว
                notifyPOS(charge.id, 'failed', charge.failure_message);
                updateOrderStatus(charge.metadata.order_id, 'failed');
                console.log(`WeChat Pay UPM failed: ${charge.id}, reason: ${charge.failure_message}`);
            }
        }
    }

    res.status(200).send('OK');
});

การเชื่อมต่อเครื่องสแกนบาร์โค้ด

ข้อกำหนดเครื่องสแกน

เครื่องสแกนบาร์โค้ดมาตรฐานใดๆ ที่เข้ากันได้กับระบบ POS ของคุณสามารถใช้กับ WeChat Pay UPM ได้ เครื่องสแกนต้องอ่านบาร์โค้ดตัวเลขจากแอป WeChat ของลูกค้า

เครื่องสแกนที่รองรับ:

เครื่องสแกนบาร์โค้ด USB (1D/2D)
เครื่องสแกนบาร์โค้ด Bluetooth
เครื่องสแกน POS ในตัว
กล้องอุปกรณ์มือถือพร้อมซอฟต์แวร์สแกน

รูปแบบบาร์โค้ด

บาร์โค้ดชำระเงิน WeChat โดยทั่วไป:

รหัสตัวเลข 18 หลัก
เริ่มต้นด้วย prefix เฉพาะ (10, 11, 12, 13, 14, 15)
มีอายุจำกัด (โดยทั่วไป 1 นาที)

// ตรวจสอบรูปแบบบาร์โค้ด WeChat
function isValidWeChatBarcode(barcode) {
    // บาร์โค้ด WeChat โดยทั่วไปมี 18 หลัก
    // และเริ่มต้นด้วย prefix เฉพาะ
    const validPrefixes = ['10', '11', '12', '13', '14', '15'];

    if (!/^\d{18}$/.test(barcode)) {
        return false;
    }

    const prefix = barcode.substring(0, 2);
    return validPrefixes.includes(prefix);
}

ตัวอย่างการเชื่อมต่อ POS

// การเชื่อมต่อเครื่อง POS
class WeChatPayUPM {
    constructor(omise) {
        this.omise = omise;
    }

    async processPayment(barcode, amount, orderId) {
        // ตรวจสอบข้อมูลนำเข้า
        if (!this.validateBarcode(barcode)) {
            return { success: false, error: 'Invalid barcode format' };
        }

        if (!this.validateAmount(amount)) {
            return { success: false, error: 'Invalid amount' };
        }

        try {
            const charge = await this.omise.charges.create({
                amount: amount,
                currency: 'THB',
                source: {
                    type: 'wechat_pay_upm',
                    barcode: barcode
                },
                metadata: {
                    order_id: orderId,
                    timestamp: new Date().toISOString()
                }
            });

            return {
                success: true,
                chargeId: charge.id,
                status: charge.status,
                requiresConfirmation: charge.status === 'pending'
            };

        } catch (error) {
            return {
                success: false,
                error: error.message
            };
        }
    }

    validateBarcode(barcode) {
        return /^\d{18}$/.test(barcode);
    }

    validateAmount(amount) {
        return amount >= 2000 && amount <= 15000000;
    }
}

// การใช้งาน
const pos = new WeChatPayUPM(omise);
const result = await pos.processPayment('130991292552725093', 150000, 'ORD-12345');

if (result.success) {
    if (result.requiresConfirmation) {
        displayMessage('Please ask customer to confirm in WeChat app');
        waitForWebhook(result.chargeId);
    } else {
        printReceipt(result.chargeId);
    }
} else {
    displayError(result.error);
}

ค่าสถานะ Charge

สถานะ	คำอธิบาย
`pending`	สร้าง charge แล้ว รอลูกค้ายืนยันในแอป WeChat
`successful`	ชำระเงินสำเร็จ
`failed`	การชำระเงินถูกปฏิเสธหรือล้มเหลว
`expired`	charge หมดอายุ (24 ชั่วโมงโดยไม่มีการอนุมัติ)

การหมดอายุของ Charge

Charge ของ WeChat Pay UPM จะหมดอายุหลังจาก 24 ชั่วโมง หากลูกค้าไม่อนุมัติ สำหรับการชำระเงินหน้าร้าน โดยทั่วไปหมายความว่าลูกค้ายกเลิกธุรกรรม

รหัสความล้มเหลว

รหัส	คำอธิบาย	การดำเนินการที่แนะนำ
`payment_expired`	การอนุมัติการชำระเงินหมดอายุ	สร้าง charge ใหม่
`payment_rejected`	การชำระเงินถูกปฏิเสธโดย WeChat/ธนาคาร	ขอให้ลูกค้าลองใหม่หรือใช้วิธีการชำระเงินอื่น
`insufficient_fund`	ยอดเงินในกระเป๋าไม่เพียงพอ	ขอให้ลูกค้าเติมเงินหรือใช้วิธีการชำระเงินอื่น
`failed_processing`	ข้อผิดพลาดในการประมวลผลทั่วไป	ลองทำธุรกรรมใหม่
`invalid_barcode`	บาร์โค้ดไม่ถูกต้องหรือหมดอายุ	ขอให้ลูกค้ารีเฟรชรหัสชำระเงิน

// จัดการรหัสความล้มเหลว
function handlePaymentFailure(charge) {
    const failureCode = charge.failure_code;
    const failureMessage = charge.failure_message;

    const errorMessages = {
        'payment_expired': 'Payment expired. Please try again.',
        'payment_rejected': 'Payment was declined. Please try a different payment method.',
        'insufficient_fund': 'Insufficient funds. Please top up your WeChat wallet.',
        'failed_processing': 'Processing error. Please try again.',
        'invalid_barcode': 'Invalid barcode. Please refresh your payment code in WeChat.'
    };

    return errorMessages[failureCode] || failureMessage || 'Payment failed. Please try again.';
}

การสนับสนุนการคืนเงิน

WeChat Pay UPM รองรับการคืนเงินเต็มจำนวนและบางส่วนภายใน 90 วันนับจากธุรกรรมเดิม

คืนเงินเต็มจำนวน

// คืนเงินเต็มจำนวน
const refund = await omise.charges.createRefund('chrg_test_...', {
    amount: 150000  // จำนวนเต็ม
});

console.log('Refund ID:', refund.id);
console.log('Refund status:', refund.status);

คืนเงินบางส่วน

// คืนเงินบางส่วน
const partialRefund = await omise.charges.createRefund('chrg_test_...', {
    amount: 50000  // จำนวนบางส่วน
});

การคืนเงินด้วย cURL

# คืนเงินเต็มจำนวน
curl https://api.omise.co/charges/chrg_test_xxx/refunds \
  -u $OMISE_SECRET_KEY: \
  -d "amount=150000"

# คืนเงินบางส่วน
curl https://api.omise.co/charges/chrg_test_xxx/refunds \
  -u $OMISE_SECRET_KEY: \
  -d "amount=50000"

ระยะเวลาการคืนเงิน

การคืนเงินจะถูกประมวลผลภายใน 1-3 วันทำการ
ลูกค้าจะได้รับเงินคืนใน WeChat Wallet
สามารถคืนเงินบางส่วนหลายครั้งได้ไม่เกินจำนวน charge เดิม

ตัวอย่างการติดตั้งใช้งานฉบับเต็ม

// เซิร์ฟเวอร์ Express.js พร้อม WeChat Pay UPM
const express = require('express');
const omise = require('omise')({
    secretKey: process.env.OMISE_SECRET_KEY
});

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

// เก็บธุรกรรมที่รอดำเนินการ
const pendingTransactions = new Map();

// ประมวลผลการชำระเงิน WeChat Pay UPM
app.post('/api/pos/wechat-upm', async (req, res) => {
    const { barcode, amount, order_id, terminal_id } = req.body;

    // ตรวจสอบบาร์โค้ด
    if (!barcode || !/^\d{18}$/.test(barcode)) {
        return res.status(400).json({
            success: false,
            error: 'Invalid WeChat payment barcode'
        });
    }

    // ตรวจสอบจำนวนเงิน (THB 20 - THB 150,000)
    if (amount < 2000 || amount > 15000000) {
        return res.status(400).json({
            success: false,
            error: 'Amount must be between 20 and 150,000'
        });
    }

    try {
        const charge = await omise.charges.create({
            amount: amount,
            currency: 'THB',
            source: {
                type: 'wechat_pay_upm',
                barcode: barcode
            },
            metadata: {
                order_id: order_id,
                terminal_id: terminal_id,
                payment_method: 'wechat_pay_upm'
            }
        });

        // จัดการความสำเร็จทันที
        if (charge.status === 'successful') {
            await processSuccessfulPayment(charge);
            return res.json({
                success: true,
                charge_id: charge.id,
                status: 'successful',
                message: 'Payment successful'
            });
        }

        // จัดการสถานะรอดำเนินการ (ลูกค้าต้องยืนยัน)
        if (charge.status === 'pending') {
            pendingTransactions.set(charge.id, {
                order_id: order_id,
                terminal_id: terminal_id,
                created_at: new Date()
            });

            return res.json({
                success: true,
                charge_id: charge.id,
                status: 'pending',
                message: 'Ask customer to confirm payment in WeChat app'
            });
        }

        // จัดการความล้มเหลว
        return res.json({
            success: false,
            charge_id: charge.id,
            status: charge.status,
            error: charge.failure_message || 'Payment failed'
        });

    } catch (error) {
        console.error('WeChat Pay UPM error:', error);
        return res.status(500).json({
            success: false,
            error: error.message
        });
    }
});

// ตรวจสอบสถานะการชำระเงิน (สำหรับ polling)
app.get('/api/pos/check-status/:chargeId', async (req, res) => {
    try {
        const charge = await omise.charges.retrieve(req.params.chargeId);
        res.json({
            charge_id: charge.id,
            status: charge.status,
            paid: charge.paid,
            failure_message: charge.failure_message
        });
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

// ตัวจัดการ Webhook
app.post('/webhooks/omise', async (req, res) => {
    const event = req.body;

    if (event.key === 'charge.complete') {
        const charge = event.data;

        if (charge.source && charge.source.type === 'wechat_pay_upm') {
            const pendingTx = pendingTransactions.get(charge.id);

            if (charge.status === 'successful') {
                await processSuccessfulPayment(charge);

                // แจ้งเตือนเครื่อง POS
                if (pendingTx) {
                    notifyTerminal(pendingTx.terminal_id, {
                        type: 'payment_success',
                        charge_id: charge.id,
                        order_id: pendingTx.order_id
                    });
                }
            } else if (charge.status === 'failed') {
                // แจ้งเตือนเครื่อง POS ว่าล้มเหลว
                if (pendingTx) {
                    notifyTerminal(pendingTx.terminal_id, {
                        type: 'payment_failed',
                        charge_id: charge.id,
                        order_id: pendingTx.order_id,
                        error: charge.failure_message
                    });
                }
            }

            pendingTransactions.delete(charge.id);
        }
    }

    res.status(200).send('OK');
});

// ประมวลผลการคืนเงิน
app.post('/api/pos/refund', async (req, res) => {
    const { charge_id, amount } = req.body;

    try {
        const refund = await omise.charges.createRefund(charge_id, {
            amount: amount
        });

        res.json({
            success: true,
            refund_id: refund.id,
            status: refund.status
        });
    } catch (error) {
        res.status(500).json({
            success: false,
            error: error.message
        });
    }
});

// ฟังก์ชันตัวช่วย
async function processSuccessfulPayment(charge) {
    await updateOrderStatus(charge.metadata.order_id, 'paid');
    await logTransaction(charge);
}

function notifyTerminal(terminalId, message) {
    // การติดตั้งใช้งานขึ้นอยู่กับระบบ POS ของคุณ
    // สามารถใช้ WebSocket, polling หรือ push notifications
}

async function updateOrderStatus(orderId, status) {
    // อัปเดตคำสั่งซื้อในฐานข้อมูลของคุณ
}

async function logTransaction(charge) {
    // บันทึกธุรกรรมสำหรับการรายงาน
}

app.listen(3000, () => {
    console.log('WeChat Pay UPM server running on port 3000');
});

แนวทางปฏิบัติที่ดีที่สุด

1. ฝึกอบรมพนักงานเกี่ยวกับขั้นตอนการชำระเงิน

ตรวจสอบให้แน่ใจว่าพนักงานเข้าใจขั้นตอนการชำระเงิน UPM:

ขอให้ลูกค้าเปิด WeChat และแสดงรหัสชำระเงิน
สแกนบาร์โค้ดอย่างรวดเร็ว (รหัสหมดอายุหลังจาก ~1 นาที)
รอการยืนยันหรือขอให้ลูกค้าอนุมัติในแอป

2. จัดการบาร์โค้ดหมดอายุ

บาร์โค้ดชำระเงิน WeChat จะรีเฟรชอัตโนมัติแต่หมดอายุเร็ว:

// หากสแกนบาร์โค้ดล้มเหลว ขอให้ลูกค้ารีเฟรช
if (charge.failure_code === 'invalid_barcode') {
    displayMessage('Please ask customer to refresh their WeChat payment code');
}

3. ติดตั้งใช้งานการจัดการ Timeout

// ตั้งค่า timeout สำหรับการชำระเงินที่รอดำเนินการ
const PAYMENT_TIMEOUT = 60000; // 60 วินาที

async function waitForPayment(chargeId) {
    return new Promise((resolve, reject) => {
        const timeout = setTimeout(() => {
            reject(new Error('Payment confirmation timeout'));
        }, PAYMENT_TIMEOUT);

        // ฟัง webhook หรือ poll
        onPaymentComplete(chargeId, (result) => {
            clearTimeout(timeout);
            resolve(result);
        });
    });
}

4. แสดงข้อความสถานะที่ชัดเจน

function getStatusMessage(status, failureCode) {
    const messages = {
        'pending': 'Waiting for customer confirmation...',
        'successful': 'Payment successful!',
        'failed': getFailureMessage(failureCode),
        'expired': 'Payment expired. Please try again.'
    };
    return messages[status] || 'Unknown status';
}

5. ใช้ทั้ง Webhook และ Polling

สำหรับการยืนยันการชำระเงินที่เชื่อถือได้ ใช้ webhook เป็นหลักและ polling เป็นสำรอง:

class PaymentMonitor {
    constructor(chargeId) {
        this.chargeId = chargeId;
        this.resolved = false;
    }

    async monitor() {
        // เริ่ม polling เป็นสำรอง
        const pollInterval = setInterval(async () => {
            if (this.resolved) {
                clearInterval(pollInterval);
                return;
            }

            const charge = await checkChargeStatus(this.chargeId);
            if (charge.status !== 'pending') {
                this.resolved = true;
                clearInterval(pollInterval);
                this.onComplete(charge);
            }
        }, 3000);

        // หมดเวลาหลัง 2 นาที
        setTimeout(() => {
            if (!this.resolved) {
                clearInterval(pollInterval);
                this.onTimeout();
            }
        }, 120000);
    }
}

6. ตรวจสอบขีดจำกัดจำนวนเงิน

function validateWeChatUPMAmount(amount) {
    const MIN_AMOUNT = 2000;   // THB 20.00
    const MAX_AMOUNT = 15000000; // THB 150,000.00

    if (amount < MIN_AMOUNT) {
        return { valid: false, error: `Minimum amount is 20.00` };
    }

    if (amount > MAX_AMOUNT) {
        return { valid: false, error: `Maximum amount is 150,000.00` };
    }

    return { valid: true };
}

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

WeChat Pay UPM คืออะไร?

WeChat Pay UPM (User-Presented Mode) หรือที่เรียกว่า "B scan C" (Business scans Customer) เป็นวิธีการชำระเงินหน้าร้านที่ลูกค้าแสดงบาร์โค้ดชำระเงินในแอป WeChat และร้านค้าสแกนด้วยเครื่องสแกนบาร์โค้ด ซึ่งตรงข้ามกับ MPM (Merchant-Presented Mode) ที่ลูกค้าสแกน QR Code ของร้านค้า

WeChat Pay UPM และ MPM แตกต่างกันอย่างไร?

คุณสมบัติ	UPM (User-Presented Mode)	MPM (Merchant-Presented Mode)
ใครแสดงรหัส	ลูกค้าแสดงบาร์โค้ด	ร้านค้าแสดง QR Code
ใครสแกน	ร้านค้าสแกนบาร์โค้ดลูกค้า	ลูกค้าสแกน QR ร้านค้า
ความเร็ว	เร็วกว่า (5-15 วินาที)	ช้ากว่า (30-60 วินาที)
ฮาร์ดแวร์ที่ต้องการ	ต้องมีเครื่องสแกนบาร์โค้ด	ไม่ต้องมีฮาร์ดแวร์
เหมาะสำหรับ	ร้านค้าปลีกปริมาณสูง, บริการด่วน	ร้านค้าปลีกทั่วไป, ร้านอาหาร

UPM โดยทั่วไปเร็วกว่าเพราะต้องการขั้นตอนน้อยกว่าจากลูกค้า

ต้องใช้เครื่องสแกนบาร์โค้ดประเภทใด?

เครื่องสแกนบาร์โค้ด 1D/2D มาตรฐานใดๆ ที่สามารถอ่านบาร์โค้ดตัวเลขได้จะใช้งานได้ ระบบ POS สมัยใหม่ส่วนใหญ่มีเครื่องสแกนที่เข้ากันได้ เครื่องสแกนต้องอ่านบาร์โค้ดตัวเลข 18 หลักที่แสดงในแอป WeChat ของลูกค้า เครื่องสแกน USB, Bluetooth และ POS ในตัวทั้งหมดเข้ากันได้

บาร์โค้ดชำระเงินของลูกค้ามีอายุนานเท่าใด?

บาร์โค้ดชำระเงิน WeChat จะรีเฟรชอัตโนมัติและโดยทั่วไปมีอายุประมาณ 1 นาที หากสแกนล้มเหลวด้วยข้อผิดพลาด "invalid_barcode" ให้ขอให้ลูกค้ารีเฟรชรหัสชำระเงินโดยดึงหน้าจอลงในส่วนการชำระเงินของ WeChat

ทำไม charge ของฉันค้างที่สถานะ "pending"?

สถานะ pending หมายความว่าลูกค้าต้องยืนยันการชำระเงินในแอป WeChat ซึ่งอาจเกิดขึ้นกับธุรกรรมจำนวนมากหรือตามการตั้งค่าความปลอดภัยของลูกค้า ขอให้ลูกค้าตรวจสอบแอป WeChat สำหรับข้อความยืนยันการชำระเงิน charge จะหมดอายุหลัง 24 ชั่วโมงหากไม่ได้รับการยืนยัน

สามารถคืนเงินธุรกรรม WeChat Pay UPM ได้หรือไม่?

ได้ WeChat Pay UPM รองรับการคืนเงินเต็มจำนวนและบางส่วนภายใน 90 วันนับจากธุรกรรมเดิม การคืนเงินจะถูกประมวลผลภายใน 1-3 วันทำการและคืนไปยัง WeChat Wallet ของลูกค้า

การทดสอบ

โหมดทดสอบ

WeChat Pay UPM สามารถทดสอบได้โดยใช้ API key ทดสอบของคุณ:

ขั้นตอนการทดสอบ:

สร้าง charge ด้วย API key ทดสอบและบาร์โค้ดทดสอบ
ในโหมดทดสอบ ใช้ Omise Dashboard เพื่อจำลองการชำระเงินสำเร็จ
ตรวจสอบการจัดการ webhook

บาร์โค้ดทดสอบ:

# ใช้บาร์โค้ดทดสอบรูปแบบที่ถูกต้อง
curl https://api.omise.co/charges \
  -u skey_test_YOUR_SECRET_KEY: \
  -d "amount=150000" \
  -d "currency=THB" \
  -d "source[type]=wechat_pay_upm" \
  -d "source[barcode]=130000000000000001"

สถานการณ์การทดสอบ:

ชำระเงินสำเร็จ: ตรวจสอบว่า POS ได้รับการยืนยัน
ชำระเงินล้มเหลว: ทดสอบการจัดการข้อผิดพลาดและตรรกะการลองใหม่
สถานะ pending: ทดสอบขั้นตอนการยืนยันของลูกค้า
หมดเวลา: ทดสอบการจัดการ charge ที่หมดอายุ
การคืนเงิน: ทดสอบขั้นตอนการคืนเงินเต็มจำนวนและบางส่วน

หมายเหตุสำคัญ:

โหมดทดสอบไม่ได้เชื่อมต่อกับเซิร์ฟเวอร์ WeChat จริง
ใช้ "Actions" ใน Omise Dashboard เพื่อทำเครื่องหมาย charge ว่าสำเร็จ/ล้มเหลว
ทดสอบการจัดการ webhook เสมอก่อนเปิดใช้งานจริง
ทดสอบด้วยค่าจำนวนเงินต่างๆ (ขีดจำกัดต่ำสุด/สูงสุด)

สำหรับแนวทางการทดสอบฉบับเต็ม ดูที่ เอกสารการทดสอบ

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

WeChat Pay - การชำระเงิน WeChat Pay ออนไลน์
WeChat Pay MPM - Merchant-Presented Mode (ลูกค้าสแกน)
ภาพรวมการชำระเงิน QR - วิธีการชำระเงิน QR ทั้งหมด
Alipay+ UPM - ขั้นตอน UPM ที่คล้ายกันสำหรับ Alipay+
Webhooks - จัดการเหตุการณ์การชำระเงิน
การคืนเงิน - นโยบายและขั้นตอนการคืนเงิน
การทดสอบ - ทดสอบการเชื่อมต่อ WeChat Pay UPM

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

สร้าง UPM charge แรกของคุณ
ตั้งค่าการเชื่อมต่อเครื่องสแกนบาร์โค้ด
ติดตั้งใช้งานการจัดการ webhook
ทดสอบขั้นตอนการชำระเงิน
เปิดใช้งานจริง

ภาพรวม​

ภูมิภาคที่รองรับ​

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

การติดตั้งใช้งาน​

สร้าง Charge ด้วยบาร์โค้ด​

จัดการ Charge Response​

จัดการการแจ้งเตือน Webhook​

การเชื่อมต่อเครื่องสแกนบาร์โค้ด​

ข้อกำหนดเครื่องสแกน​

รูปแบบบาร์โค้ด​

ตัวอย่างการเชื่อมต่อ POS​

ค่าสถานะ Charge​

รหัสความล้มเหลว​

การสนับสนุนการคืนเงิน​

คืนเงินเต็มจำนวน​

คืนเงินบางส่วน​

การคืนเงินด้วย cURL​

ตัวอย่างการติดตั้งใช้งานฉบับเต็ม​

แนวทางปฏิบัติที่ดีที่สุด​

1. ฝึกอบรมพนักงานเกี่ยวกับขั้นตอนการชำระเงิน​

2. จัดการบาร์โค้ดหมดอายุ​

3. ติดตั้งใช้งานการจัดการ Timeout​

4. แสดงข้อความสถานะที่ชัดเจน​

5. ใช้ทั้ง Webhook และ Polling​

6. ตรวจสอบขีดจำกัดจำนวนเงิน​

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

การทดสอบ​

โหมดทดสอบ​

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

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