Rabbit LINE Pay

รับชำระเงินจากผู้ใช้ LINE กว่า 10 ล้านคนในประเทศไทยผ่าน Rabbit LINE Pay กระเป๋าเงินดิจิทัลที่รวมรางวัล Rabbit Card เข้ากับแพลตฟอร์มการส่งข้อความ LINE ที่ได้รับความนิยม

ภาพรวม

สถิติผู้ใช้

จำนวนผู้ใช้เป็นค่าประมาณและอิงจากข้อมูลที่เปิดเผยต่อสาธารณะ จำนวนผู้ใช้งานจริงอาจแตกต่างกันไป

Rabbit LINE Pay เป็นบริการชำระเงินดิจิทัลที่เกิดจากความร่วมมือระหว่าง LINE (ยักษ์ใหญ่ด้านการส่งข้อความของญี่ปุ่น) และกลุ่ม BTS (ผู้ดำเนินการ Rabbit Card ของไทย) ช่วยให้ผู้ใช้ LINE ในประเทศไทยสามารถชำระเงินผ่านแอป LINE พร้อมทั้งสะสมคะแนน Rabbit Rewards ทำให้เป็นที่นิยมอย่างมากในหมู่ผู้ใช้ขนส่งสาธารณะกรุงเทพฯและวัยทำงาน

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

• ✅ ผู้ใช้ 10+ ล้านคน - เข้าถึงผู้ใช้ LINE ชาวไทยจำนวนมาก
• ✅ Rabbit Rewards - ลูกค้าสะสมคะแนนจากทุกธุรกรรม
• ✅ รวมกับ LINE - ชำระเงินได้อย่างราบรื่นในแอปส่งข้อความ
• ✅ ระบบนิเวศ BTS - เชื่อมต่อกับระบบขนส่งมวลชนกรุงเทพฯ
• ✅ ยืนยันทันที - ประมวลผลการชำระเงินแบบเรียลไทม์
• ✅ ไม่จำเป็นต้องมีบัญชีธนาคาร - เติมเงินผ่านร้านสะดวกซื้อ

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

ภูมิภาค	สกุลเงิน	จำนวนขั้นต่ำ	จำนวนสูงสุด	วงเงินรายวัน
ประเทศไทย	THB	฿20.00	฿150,000	แตกต่างกัน*

*วงเงินอาจแตกต่างกันตามระดับการยืนยันตัวตนของลูกค้าและไม่ได้ระบุโดย Omise อย่างครบถ้วน

ระดับการยืนยันตัวตน

ระดับ	วงเงินรายวัน	วิธีเติมเงิน	ข้อกำหนด
พื้นฐาน	฿150,000	บัตรเครดิต โอนเงินผ่านธนาคาร	หมายเลขโทรศัพท์
ยืนยันแล้ว	฿150,000	+ ร้านสะดวกซื้อ Rabbit Card	การยืนยันบัตรประชาชน

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

ประสบการณ์ของลูกค้า:

1. ลูกค้าเลือก "Rabbit LINE Pay" ที่หน้าชำระเงิน
2. เปลี่ยนเส้นทางไปยังแอป LINE (หรือ LINE web หากอยู่บนเดสก์ท็อป)
3. ตรวจสอบรายละเอียดธุรกรรมใน LINE
4. ยืนยันตัวตนด้วยรหัสผ่าน LINE หรือไบโอเมตริกส์
5. ยืนยันการชำระเงิน
6. ได้รับคะแนน Rabbit Rewards
7. กลับสู่เว็บไซต์ร้านค้า

เวลาในการทำรายการโดยเฉลี่ย: 1-3 นาที

ตัวอย่างขั้นตอนการชำระเงิน

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

วิธีการสแกน QR code บนเดสก์ท็อป:

• ❶ เลือก Rabbit LINE Pay - ลูกค้าเลือกตัวเลือกการชำระเงิน
• ❷ สร้าง QR code - ระบบสร้าง QR การชำระเงินที่ไม่ซ้ำกัน
• ❸ เปิดแอป LINE - ลูกค้าเปิด LINE บนอุปกรณ์มือถือ
• ❹ สแกน QR - ใช้เครื่องสแกน QR ในตัวของ LINE เพื่อแคปเจอร์โค้ด
• ❺ รายละเอียดการชำระเงิน - ข้อมูลธุรกรรมปรากฏในแอป LINE
• ❻ ใส่รหัสผ่าน - ยืนยันตัวตนด้วยรหัสผ่าน LINE Pay
• ❼ ยืนยันการชำระเงิน - แตะเพื่ออนุญาตธุรกรรม
• ❽ รับคะแนน Rabbit - รางวัลถูกเครดิตโดยอัตโนมัติ
• ❾ เสร็จสมบูรณ์ - ชำระเงินสำเร็จ กลับสู่ร้านค้า

ขั้นตอนการเข้าสู่ระบบ - ขั้นตอนที่ 1:

การยืนยันตัวตนผ่านเว็บ (ส่วนที่ 1):

• ❶ เลือก Rabbit LINE Pay - ลูกค้าเลือกที่หน้าชำระเงิน
• ❷ เปลี่ยนเส้นทางไปยัง LINE - ไปที่หน้าอนุญาต LINE Pay
• ❸ พร้อมท์เข้าสู่ระบบ - ใส่ข้อมูลประจำตัวบัญชี LINE
• ❹ อีเมล/โทรศัพท์ - ป้อนอีเมลหรือหมายเลขโทรศัพท์ที่ลงทะเบียน LINE
• ❺ รหัสผ่าน - ใส่รหัสผ่านบัญชี LINE
• ❻ การยืนยันสองปัจจัย - ทำการยืนยันสองปัจจัยให้เสร็จสิ้นหากเปิดใช้งาน

ขั้นตอนการเข้าสู่ระบบ - ขั้นตอนที่ 2:

การอนุญาตในแอป (ส่วนที่ 2):

• ❼ เปิดแอป LINE - เปลี่ยนเส้นทางอัตโนมัติไปยังแอปพลิเคชัน LINE
• ❽ ตรวจสอบการชำระเงิน - ชื่อร้านค้า จำนวนเงิน และคะแนน Rabbit ที่จะได้รับ
• ❾ เลือกแหล่งชำระเงิน - เลือกบัตรที่เชื่อมโยงหรือยอดเงิน LINE Pay
• ❿ ยืนยันตัวตน - ยืนยันด้วยรหัสผ่านหรือไบโอเมตริกส์
• ⓫ ประมวลผลการชำระเงิน - หักเงิน เครดิต Rabbit Rewards
• ⓬ สำเร็จ - ยืนยันใน LINE กลับสู่เว็บไซต์ร้านค้า

การนำไปใช้

ขั้นตอนที่ 1: สร้าง Source ของ Rabbit LINE Pay

cURL

curl https://api.omise.co/sources \
  -u skey_test_YOUR_SECRET_KEY: \
  -d "type=rabbit_linepay" \
  -d "amount=100000" \
  -d "currency=THB"

Node.js

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

const source = await omise.sources.create({
    type: 'rabbit_linepay',
    amount: 100000,  // THB 1,000.00
    currency: 'THB'
});

PHP

<?php
$source = OmiseSource::create(array(
    'type' => 'rabbit_linepay',
    'amount' => 100000,
    'currency' => 'THB'
));
?>

Python

import omise

omise.api_secret = 'skey_test_YOUR_SECRET_KEY'

source = omise.Source.create(
    type='rabbit_linepay',
    amount=100000,
    currency='THB'
)

Ruby

require 'omise'

Omise.api_key = 'skey_test_YOUR_SECRET_KEY'

source = Omise::Source.create({
  type: 'rabbit_linepay',
  amount: 100000,
  currency: 'THB'
})

Go

source, err := client.Sources().Create(&operations.CreateSource{
    Type:     "rabbit_linepay",
    Amount:   100000,
    Currency: "THB",
})

Java

Source source = client.sources().create(new Source.CreateParams()
    .type("rabbit_linepay")
    .amount(100000L)
    .currency("THB"));

C#

var source = await client.Sources.Create(new CreateSourceRequest
{
    Type = "rabbit_linepay",
    Amount = 100000,
    Currency = "THB"
});

การตอบกลับ:

{
  "object": "source",
  "id": "src_test_5rt6s9vah5lkvi1rh9c",
  "type": "rabbit_linepay",
  "flow": "redirect",
  "amount": 100000,
  "currency": "THB"
}

ขั้นตอนที่ 2: สร้าง Charge

curl https://api.omise.co/charges \
  -u skey_test_YOUR_SECRET_KEY: \
  -d "amount=100000" \
  -d "currency=THB" \
  -d "source=src_test_5rt6s9vah5lkvi1rh9c" \
  -d "return_uri=https://yourdomain.com/payment/callback"

ขั้นตอนที่ 3: เปลี่ยนเส้นทางลูกค้า

app.post('/checkout/rabbit-linepay', async (req, res) => {
    try {
        const { amount, order_id, customer_email } = req.body;

        // ตรวจสอบจำนวนเงิน
        if (amount < 100 || amount > 5000000) {
            return res.status(400).json({
                error: 'Amount must be between ฿1 and ฿50,000'
            });
        }

        // สร้าง source
        const source = await omise.sources.create({
            type: 'rabbit_linepay',
            amount: amount,
            currency: 'THB'
        });

        // สร้าง charge
        const charge = await omise.charges.create({
            amount: amount,
            currency: 'THB',
            source: source.id,
            return_uri: `${process.env.BASE_URL}/payment/callback`,
            metadata: {
                order_id: order_id,
                customer_email: customer_email
            }
        });

        // เปลี่ยนเส้นทางไปยัง Rabbit LINE Pay
        res.redirect(charge.authorize_uri);

    } catch (error) {
        console.error('Rabbit LINE Pay error:', error);
        res.status(500).json({ error: error.message });
    }
});

ขั้นตอนที่ 4: จัดการการกลับมา

app.get('/payment/callback', async (req, res) => {
    try {
        const chargeId = req.query.charge_id;
        const charge = await omise.charges.retrieve(chargeId);

        if (charge.status === 'successful') {
            await processOrder(charge.metadata.order_id);
            res.redirect('/payment-success?rewards=earned');
        } else if (charge.status === 'failed') {
            res.redirect('/payment-failed?reason=' + charge.failure_message);
        } else {
            res.redirect('/payment-pending');
        }
    } catch (error) {
        res.redirect('/payment-error');
    }
});

ขั้นตอนที่ 5: จัดการ Webhook

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

    if (event.key === 'charge.complete' && event.data.source.type === 'rabbit_linepay') {
        const charge = event.data;

        if (charge.status === 'successful') {
            processOrder(charge.metadata.order_id);
            sendConfirmationEmail(charge.metadata.customer_email);

            // บันทึก Rabbit Rewards ที่ได้รับ (หากมี)
            console.log(`Payment successful. ลูกค้า earned Rabbit Rewards.`);
        } else if (charge.status === 'failed') {
            handleFailedPayment(charge.metadata.order_id);
        }
    }

    res.sendStatus(200);
});

ตัวอย่างการนำไปใช้แบบสมบูรณ์

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

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

app.post('/checkout/rabbit-linepay', async (req, res) => {
    try {
        const { amount, order_id, customer_email, customer_name } = req.body;

        // ตรวจสอบจำนวนเงิน (฿1 - ฿50,000)
        if (amount < 100 || amount > 5000000) {
            return res.status(400).json({
                error: 'Amount must be between ฿1 and ฿50,000'
            });
        }

        // คำนวณคะแนน Rabbit Rewards โดยประมาณ (ตัวอย่าง: 1% ของจำนวนเงิน)
        const estimatedPoints = Math.floor(amount / 100);

        // สร้าง source
        const source = await omise.sources.create({
            type: 'rabbit_linepay',
            amount: amount,
            currency: 'THB'
        });

        // สร้าง charge
        const charge = await omise.charges.create({
            amount: amount,
            currency: 'THB',
            source: source.id,
            return_uri: `${process.env.BASE_URL}/payment/callback`,
            metadata: {
                order_id: order_id,
                customer_email: customer_email,
                customer_name: customer_name,
                payment_method: 'rabbit_linepay',
                estimated_rewards: estimatedPoints
            }
        });

        // ส่งคืน URL การอนุญาต
        res.json({
            authorize_uri: charge.authorize_uri,
            charge_id: charge.id,
            estimated_rewards: estimatedPoints
        });

    } catch (error) {
        console.error('Rabbit LINE Pay error:', error);
        res.status(500).json({ error: error.message });
    }
});

// ตัวจัดการ callback
app.get('/payment/callback', async (req, res) => {
    try {
        const chargeId = req.query.charge_id;
        const charge = await omise.charges.retrieve(chargeId);

        if (charge.status === 'successful') {
            const rewards = charge.metadata.estimated_rewards || 0;
            res.redirect(`/order-success?order=${charge.metadata.order_id}&rewards=${rewards}`);
        } else {
            res.redirect(`/payment-failed?charge=${chargeId}`);
        }
    } catch (error) {
        res.redirect('/payment-error');
    }
});

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

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

        if (charge.source.type === 'rabbit_linepay') {
            if (charge.status === 'successful') {
                updateOrderStatus(charge.metadata.order_id, 'paid');
                sendConfirmation(charge.metadata.customer_email, {
                    amount: charge.amount,
                    rewards: charge.metadata.estimated_rewards
                });
            } else {
                updateOrderStatus(charge.metadata.order_id, 'failed');
            }
        }
    }

    res.sendStatus(200);
});

// ฟังก์ชันช่วยเหลือ
async function updateOrderStatus(orderId, status) {
    await db.orders.update({ id: orderId }, { status: status });
}

async function sendConfirmation(email, details) {
    // ส่งอีเมลยืนยันการชำระเงินและข้อมูล Rabbit Rewards
    // การนำไปใช้ขึ้นอยู่กับบริการอีเมล
}

app.listen(3000);

การรองรับการคืนเงิน

Rabbit LINE Pay รองรับการคืนเงินเต็มจำนวนเท่านั้นภายใน 30 วัน:

// คืนเงินเต็มจำนวนเท่านั้น (ไม่คืนบางส่วน)
const refund = await omise.charges.refund('chrg_test_...', {
    amount: 100000  // ต้องเป็นจำนวนเต็ม
});

ข้อจำกัดการคืนเงิน

• คืนเงินเต็มจำนวนเท่านั้น - ไม่รองรับการคืนเงินบางส่วน
• ช่วง 30 วัน - ต้องขอคืนเงินภายใน 30 วัน
• Rabbit Rewards - คะแนนที่ได้รับจะถูกหักออกโดยอัตโนมัติเมื่อคืนเงิน

ปัญหาที่พบบ่อยและการแก้ไข

ปัญหา: ไม่ได้ติดตั้งแอป LINE

สาเหตุ: ลูกค้าไม่มีแอป LINE บนอุปกรณ์

วิธีแก้:

function checkLINEApp() {
    const userAgent = navigator.userAgent;
    const isMobile = /Android|iPhone|iPad|iPod/i.test(userAgent);

    if (isMobile) {
        return `
            <div class="line-check">
                <p>วิธีการชำระเงินนี้ต้องใช้แอป LINE</p>
                <p>โปรดตรวจสอบให้แน่ใจว่าคุณได้ติดตั้ง LINE แล้ว:</p>
                <a href="https://line.me/download">ดาวน์โหลด LINE</a>
            </div>
        `;
    }

    return ''; // ผู้ใช้เดสก์ท็อปจะใช้ LINE web
}

ปัญหา: ยอดเงินไม่เพียงพอ

สาเหตุ: ยอดเงิน Rabbit LINE Pay ของลูกค้าต่ำเกินไป

วิธีแก้:

<div class="payment-instructions">
    <h3>ก่อนทำการชำระเงินให้เสร็จสิ้น:</h3>
    <ol>
        <li>ตรวจสอบยอดเงิน Rabbit LINE Pay ของคุณในแอป LINE</li>
        <li>หากจำเป็น ให้เติมเงิน:
            <ul>
                <li>เซเว่น-อีเลฟเว่น แฟมิลี่มาร์ท (ร้านสะดวกซื้อใดก็ได้)</li>
                <li>บัตรเครดิต/เดบิต</li>
                <li>โอนเงินผ่านธนาคาร</li>
                <li>เติมเงิน Rabbit Card ที่สถานี BTS</li>
            </ul>
        </li>
        <li>กลับมาที่นี่เพื่อทำการชำระเงินให้เสร็จสิ้น</li>
    </ol>
    <p><strong>จำนวนเงินที่ต้องชำระ: ฿{{amount}}</strong></p>
</div>

ปัญหา: เกินวงเงินรายวัน

สาเหตุ: ลูกค้าถึงวงเงินธุรกรรมรายวันแล้ว

วิธีแก้:

function handleLimitExceeded() {
    return {
        error: 'Daily limit exceeded',
        message: 'คุณถึงวงเงินรายวัน Rabbit LINE Pay แล้ว',
        suggestions: [
            'รอจนถึงวันพรุ่งนี้เพื่อทำธุรกรรมนี้ให้เสร็จสิ้น',
            'อัปเกรดเป็นบัญชียืนยันแล้วเพื่อวงเงินที่สูงขึ้น',
            'ใช้วิธีการชำระเงินทางเลือก'
        ],
        alternativeMethods: [
            'credit_card',
            'promptpay',
            'truemoney'
        ]
    };
}

ปัญหา: การชำระเงินหมดอายุ

สาเหตุ: ลูกค้าไม่ได้ทำการชำระเงินให้เสร็จภายในเวลาที่กำหนด

วิธีแก้:

// หมดเวลาการชำระเงิน 10 นาที
const PAYMENT_TIMEOUT = 10 * 60 * 1000;

setTimeout(() => {
    if (!paymentConfirmed) {
        showMessage('เซสชันการชำระเงินหมดอายุแล้ว โปรดลองอีกครั้ง');
        enableRetryButton();
    }
}, PAYMENT_TIMEOUT);

function enableRetryButton() {
    const retryBtn = document.getElementById('retry-payment');
    retryBtn.disabled = false;
    retryBtn.onclick = () => {
        window.location.href = '/checkout';
    };
}

ปัญหา: Rabbit Rewards ไม่แสดง

สาเหตุ: ปัญหาการคำนวณหรือการแสดงรางวัล

วิธีแก้:

// คำนวณและแสดง Rabbit Rewards
function displayRewardsEstimate(amount) {
    // อัตราทั่วไป: 1 คะแนนต่อ ฿100 ที่ใช้
    const points = Math.floor(amount / 10000); // จำนวนเงินเป็นสตางค์

    return `
        <div class="rewards-estimate">
            <img src="/images/rabbit-icon.svg" alt="Rabbit Rewards" width="24">
            <p>รับประมาณ <strong>${points} คะแนน Rabbit Rewards</strong></p>
            <p class="small">คะแนนจะถูกเครดิตหลังการชำระเงินสำเร็จ</p>
        </div>
    `;
}

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

1. แสดงผลประโยชน์ของ Rabbit Rewards

<div class="rabbit-linepay-benefits">
    <h3>ชำระเงินด้วย Rabbit LINE Pay</h3>
    <ul class="benefits-list">
        <li>✓ สะสมคะแนน Rabbit Rewards จากทุกการซื้อ</li>
        <li>✓ ใช้คะแนนสำหรับการโดยสาร BTS/MRT</li>
        <li>✓ ชำระเงินรวดเร็วผ่านแอป LINE</li>
        <li>✓ ปลอดภัยด้วยการยืนยันตัวตน LINE</li>
    </ul>
    <p class="rewards-note">
        <img src="/images/rabbit-icon.svg" width="20">
        <strong>รับ {{points}} คะแนน</strong> จากการซื้อนี้
    </p>
</div>

2. ให้ข้อมูลการเติมเงิน

function displayTopUpInformation() {
    return `
        <div class="topup-info">
            <h4>ต้องการเพิ่มเงินหรือไม่?</h4>
            <p>เติมเงินยอดเงิน Rabbit LINE Pay ของคุณ:</p>
            <ul>
                <li>🏪 เซเว่น-อีเลฟเว่นหรือแฟมิลี่มาร์ทใดก็ได้</li>
                <li>💳 บัตรเครดิต/เดบิตในแอป LINE</li>
                <li>🏦 โอนเงินผ่านธนาคาร</li>
                <li>🚇 เครื่องเติมเงิน BTS Rabbit Card</li>
            </ul>
            <a href="https://pay.line.me/topup" target="_blank">
                ดูคู่มือการเติมเงิน
            </a>
        </div>
    `;
}

3. จัดการมือถือกับเดสก์ท็อป

function detectPlatform() {
    const isMobile = /Android|iPhone|iPad|iPod/i.test(navigator.userAgent);

    if (isMobile) {
        // มือถือ: deep link ไปยังแอป LINE
        return {
            platform: 'mobile',
            instructions: 'คุณจะถูกเปลี่ยนเส้นทางไปยังแอป LINE'
        };
    } else {
        // เดสก์ท็อป: อินเทอร์เฟซ LINE web
        return {
            platform: 'desktop',
            instructions: 'คุณจะถูกเปลี่ยนเส้นทางไปยัง LINE web โปรดเข้าสู่ระบบด้วยบัญชี LINE ของคุณ'
        };
    }
}

4. ตรวจสอบวงเงิน

function validateRabbitLINEPayAmount(amount, verificationLevel = 'basic') {
    const limits = {
        'basic': { min: 100, max: 5000000, daily: 5000000 },
        'verified': { min: 100, max: 5000000, daily: 10000000 }
    };

    const limit = limits[verificationLevel];

    if (amount < limit.min) {
        return `จำนวนเงินขั้นต่ำคือ ฿${limit.min / 100}`;
    }

    if (amount > limit.max) {
        return `จำนวนเงินสูงสุดต่อธุรกรรมคือ ฿${limit.max / 100}`;
    }

    return null; // ถูกต้อง
}

5. แสดงคำแนะนำที่ชัดเจน

<div class="rabbit-linepay-instructions">
    <h3>วิธีการชำระเงินด้วย Rabbit LINE Pay</h3>
    <div class="steps">
        <div class="step">
            <span class="step-number">1</span>
            <p>คลิก "ชำระด้วย Rabbit LINE Pay"</p>
        </div>
        <div class="step">
            <span class="step-number">2</span>
            <p>เปิดแอป LINE เมื่อได้รับแจ้ง</p>
        </div>
        <div class="step">
            <span class="step-number">3</span>
            <p>ตรวจสอบรายละเอียดการชำระเงิน</p>
        </div>
        <div class="step">
            <span class="step-number">4</span>
            <p>ยืนยันเพื่อทำการชำระเงินให้เสร็จสิ้น</p>
        </div>
        <div class="step">
            <span class="step-number">5</span>
            <p>รับ Rabbit Rewards โดยอัตโนมัติ!</p>
        </div>
    </div>
</div>

6. ใช้ Webhook อย่างเชื่อถือได้

// Webhook เป็นวิธีการแจ้งเตือนหลัก
app.post('/webhooks/omise', handleWebhook);

// Callback เป็นสำรอง
app.get('/payment/callback', handleCallback);

// อย่าพึ่ง callback เพียงอย่างเดียวสำหรับการดำเนินการคำสั่งซื้อ

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

Rabbit LINE Pay คืออะไร?

Rabbit LINE Pay คือบริการชำระเงินดิจิทัลในประเทศไทยที่รวมแพลตฟอร์มการส่งข้อความ LINE เข้ากับระบบรางวัล Rabbit Card ผู้ใช้สามารถชำระเงินผ่านแอป LINE และสะสมคะแนน Rabbit Rewards ที่สามารถใช้สำหรับการโดยสาร BTS/MRT และซื้อสินค้าที่ร้านค้าที่ร่วมรายการ

ลูกค้าต้องมีทั้ง LINE และ Rabbit Card หรือไม่?

ลูกค้าต้องมีแอป LINE ที่เปิดใช้งาน Rabbit LINE Pay ไม่จำเป็นต้องมี Rabbit Card จริง แต่การมีช่วยให้สามารถใช้วิธีเติมเงินเพิ่มเติมและเชื่อมต่อกับระบบขนส่งมวลชนกรุงเทพฯได้

วงเงินธุรกรรมคือเท่าไร?

• ขั้นต่ำ: ฿1.00 ต่อธุรกรรม
• สูงสุด: ฿50,000 ต่อธุรกรรม
• วงเงินรายวัน: ฿50,000 (พื้นฐาน) หรือ ฿100,000 (บัญชียืนยันแล้ว)

ลูกค้าสามารถเพิ่มวงเงินได้โดยการทำการยืนยันตัวตนให้เสร็จสิ้นในแอป LINE

ลูกค้าเติมเงินยอดเงิน Rabbit LINE Pay ได้อย่างไร?

ลูกค้าสามารถเติมเงินผ่าน:

• ร้านสะดวกซื้อ (เซเว่น-อีเลฟเว่น แฟมิลี่มาร์ท ฯลฯ)
• บัตรเครดิตหรือเดบิตในแอป LINE
• โอนเงินผ่านธนาคาร
• เครื่องเติมเงิน Rabbit Card ที่สถานี BTS
• สถานที่พาร์ทเนอร์

ฉันสามารถคืนเงินการชำระเงิน Rabbit LINE Pay ได้หรือไม่?

ได้ แต่มีข้อจำกัด:

• คืนเงินเต็มจำนวนเท่านั้น - ไม่รองรับการคืนเงินบางส่วน
• ช่วง 30 วัน - ต้องคืนเงินภายใน 30 วันของธุรกรรม
• Rabbit Rewards - คะแนนที่ลูกค้าได้รับจะถูกหักออกโดยอัตโนมัติ

การชำระเงินใช้เวลานานแค่ไหน?

การชำระเงิน Rabbit LINE Pay โดยทั่วไปเกิดขึ้นภายใน 2-3 วันทำการหลังจากธุรกรรม ตรวจสอบแดชบอร์ด Omise ของคุณสำหรับกำหนดการชำระเงินเฉพาะ

ลูกค้าได้รับ Rabbit Rewards จากการซื้อทั้งหมดหรือไม่?

ใช่ ลูกค้าจะได้รับคะแนน Rabbit Rewards โดยอัตโนมัติจากธุรกรรม Rabbit LINE Pay ที่สำเร็จทั้งหมด คะแนนที่ได้รับขึ้นอยู่กับโปรแกรมรางวัลปัจจุบันของ Rabbit (โดยทั่วไปคือ 1 คะแนนต่อ ฿100 ที่ใช้) คะแนนจะถูกเครดิตหลังการยืนยันการชำระเงิน

Rabbit LINE Pay ใช้งานได้ตลอด 24 ชั่วโมง 7 วันหรือไม่?

ใช่ Rabbit LINE Pay พร้อมใช้งานตลอด 24 ชั่วโมง 7 วันสำหรับธุรกรรม อย่างไรก็ตาม วิธีการเติมเงินอาจมีความพร้อมใช้งานจำกัด (เช่น การเติมเงินที่ร้านสะดวกซื้อเฉพาะในเวลาเปิดร้าน)

จะเกิดอะไรขึ้นหากการชำระเงินล้มเหลว?

เหตุผลทั่วไปของการชำระเงินล้มเหลว:

• ยอดเงินไม่เพียงพอ
• เกินวงเงินรายวัน
• บัญชีไม่ได้รับการยืนยัน
• ปัญหาทางเทคนิคกับแอป LINE

ลูกค้าสามารถลองชำระเงินอีกครั้งหลังจากแก้ไขปัญหาหรือเลือกวิธีการชำระเงินทางเลือก

การทดสอบ

โหมดทดสอบ

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

ข้อมูลประจำตัวทดสอบ:

• ใช้ API key ทดสอบ (skey_test_xxx)
• สกุลเงิน: THB (บาทไทย)
• ไม่จำเป็นต้องมีบัญชี Rabbit LINE Pay จริง

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

1. สร้าง source และ charge ด้วย API key ทดสอบ
2. ลูกค้าเปลี่ยนเส้นทางไปยัง authorize_uri ทดสอบ
3. หน้าทดสอบจำลองขั้นตอน Rabbit LINE Pay
4. ใช้การดำเนินการแดชบอร์ด Omise เพื่อทำเครื่องหมาย charge เป็นสำเร็จ/ล้มเหลว
5. ตรวจสอบการจัดการ webhook และ return_uri

การนำการทดสอบไปใช้:

// ทดสอบ Rabbit LINE Pay
const source = await omise.sources.create({
    type: 'rabbit_linepay',
    amount: 10000,  // ฿100.00
    currency: 'THB'
});

const charge = await omise.charges.create({
    amount: 10000,
    currency: 'THB',
    source: source.id,
    return_uri: 'https://example.com/callback'
});

console.log('Test authorize URL:', charge.authorize_uri);

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

• การชำระเงินสำเร็จ: ตรวจสอบการทำคำสั่งซื้อให้เสร็จสิ้น
• การชำระเงินล้มเหลว: ทดสอบการจัดการข้อผิดพลาดและลองใหม่
• วงเงิน: ทดสอบจำนวนเงินขั้นต่ำ ฿20 และจำนวนสูงสุด
• ขั้นตอนมือถือ: ทดสอบ deep link ไปยังแอป LINE
• ยอดเงินไม่เพียงพอ: จำลองยอดเงินในกระเป๋าเงินต่ำ
• หมดเวลา: ทดสอบการชำระเงินที่ถูกละทิ้ง
• การส่ง Webhook: ตรวจสอบการแจ้งเตือน webhook ทั้งหมด

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

• โหมดทดสอบไม่เชื่อมต่อกับเซิร์ฟเวอร์ Rabbit LINE Pay จริง
• ใช้แดชบอร์ดเพื่อจำลองการเปลี่ยนแปลงสถานะการชำระเงิน
• ทดสอบขั้นตอนแอปมือถือ (การรวม LINE)
• ตรวจสอบการจัดการ webhook สำหรับสถานะ charge ทั้งหมด
• ทดสอบการตรวจสอบจำนวนเงินและวงเงิน

สำหรับแนวทางการทดสอบที่ครอบคลุม โปรดดูเอกสารการทดสอบ

ทรัพยากรที่เกี่ยวข้อง

• ภาพรวมกระเป๋าเงินดิจิทัล - ตัวเลือก e-wallet ทั้งหมด
• TrueMoney Wallet - กระเป๋าเงินไทยทางเลือก
• PromptPay - ตัวเลือก QR code
• การทดสอบ - ทดสอบการรวม Rabbit LINE Pay
• การคืนเงิน - นโยบายการคืนเงิน
• Webhooks - จัดการการแจ้งเตือนการชำระเงิน

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

1. สร้าง source ของ Rabbit LINE Pay
2. นำขั้นตอนการเปลี่ยนเส้นทางไปใช้
3. ตั้งค่าการจัดการ webhook
4. ทดสอบขั้นตอนการชำระเงิน
5. เริ่มใช้งานจริง