KakaoPay

ยอมรับการชำระเงินจาก KakaoPay ในสิงคโปร์และประเทศไทย กระเป๋าดิจิทัลที่บูรณาการซึ่งรองรับตลาดในหลายประเทศในเอเชียตะวันออกเฉียงใต้

ภาพรวม

KakaoPay เป็นบริการชำระเงินผ่านกระเป๋าดิจิทัลที่ดำเนินการในสิงคโปร์และประเทศไทย ซึ่งให้ลูกค้าได้มีตัวเลือกการชำระเงินบนมือถือที่สะดวกสบายรวมเข้ากับแพลตฟอร์มอีคอมเมิร์ซ

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

• ✅ หลายภูมิภาค - พร้อมใช้งานในสิงคโปร์และประเทศไทย
• ✅ การยืนยันที่รวดเร็ว - การตรวจสอบการชำระเงินเกือบแบบเรียลไทม์ (โดยปกติภายในไม่กี่วินาที)
• ✅ เพิ่มประสิทธิภาพสำหรับมือถือ - ประสบการณ์สมาร์ทโฟนที่ราบรื่น
• ✅ ชำระเงินได้อย่างรวดเร็ว - การยืนยันการชำระเงินแบบรวดเร็ว
• ✅ เน้นอีคอมเมิร์ซ - ได้รับความนิยมสำหรับการช้อปปิ้งออนไลน์

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

ภูมิภาค	สกุลเงิน	จำนวนต่ำสุด	จำนวนสูงสุด
สิงคโปร์	SGD	$1.00	$20,000
ประเทศไทย	THB	฿20.00	฿150,000

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

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

1. ลูกค้าเลือก KakaoPay ที่ชำระเงิน
2. เปลี่ยนเส้นทางไปยังหน้าการยืนยันตัวตน KakaoPay
3. แอป KakaoTalk เปิดโดยอัตโนมัติ (deep link)
4. ลูกค้าตรวจสอบการชำระเงินใน KakaoTalk
5. ยืนยันด้วยรหัสผ่าน/ชีวมิติ/รูปแบบ
6. กลับไปยังไซต์ของผู้ค้า
7. ได้รับการแจ้งเตือนการชำระเงินใน KakaoTalk

เวลาเสร็จสิ้นทั่วไป: 30-90 วินาที

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

การไหลการชำระเงินบนมือถือ:

ประสบการณ์มือถือที่เร็วสายฟ้า:

• ❶ เลือก KakaoPay - ลูกค้าเลือก KakaoPay ที่ชำระเงิน
• ❷ KakaoTalk เปิด - Deep link เปิดแอป KakaoTalk ทันที
• ❸ พร้อมชำระเงิน - รายละเอียดธุรกรรมปรากฏใน KakaoTalk
• ❹ ตรวจสอบรายละเอียด - แสดงชื่อผู้ค้าและจำนวนเงินที่ชำระ
• ❺ ตรวจสอบความถูกต้อง - ยืนยันด้วยรหัสผ่าน รูปแบบ หรือชีวมิติ
• ❻ ชำระเงินเสร็จสิ้น - การประมวลผลแบบทันที (เร็วที่สุดในเอเชีย - 20-40 วินาที)
• ❼ การแจ้งเตือน - ข้อความยืนยันการชำระเงินใน KakaoTalk
• ❽ กลับไป - การเปลี่ยนเส้นทางโดยอัตโนมัติไปยังผู้ค้า

การไหลการชำระเงินบนเดสก์ท็อป:

วิธีโค้ด QR สำหรับผู้ใช้เดสก์ท็อป:

• ❶ เลือก KakaoPay - ลูกค้าเลือก KakaoPay บนเดสก์ท็อป
• ❷ สร้างโค้ด QR - ระบบสร้างโค้ด QR สำหรับการชำระเงิน KakaoPay
• ❸ แสดงโค้ด QR - โค้ด QR แสดงให้เห็นอย่างชัดเจนบนหน้าจอ
• ❹ เปิด KakaoTalk - ลูกค้าเปิด KakaoTalk บนมือถือ
• ❺ สแกน QR - ใช้สแกนเนอร์ QR ในตัวของ KakaoTalk
• ❻ โหลดการชำระเงิน - รายละเอียดธุรกรรมเติมโดยอัตโนมัติในแอป
• ❼ ตรวจสอบความถูกต้อง - ยืนยันชีวมิติหรือรหัสผ่านอย่างรวดเร็ว
• ❽ สำเร็จ - ชำระเงินแล้ว เดสก์ท็อปแสดงการยืนยัน

การใช้งาน

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

cURL

curl https://api.omise.co/sources \
  -u skey_test_YOUR_SECRET_KEY: \
  -d "type=kakaopay" \
  -d "amount=1000000" \
  -d "currency=KRW"

Node.js

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

const source = await omise.sources.create({
    type: 'kakaopay',
    amount: 1000000,  // ₩10,000
    currency: 'KRW'
});

console.log('KakaoPay source:', source.id);

PHP

<?php
$source = OmiseSource::create(array(
    'type' => 'kakaopay',
    'amount' => 1000000,
    'currency' => 'KRW'
));
?>

Python

import omise

omise.api_secret = 'skey_test_YOUR_SECRET_KEY'

source = omise.Source.create(
    type='kakaopay',
    amount=1000000,
    currency='KRW'
)

Ruby

require 'omise'

Omise.api_key = 'skey_test_YOUR_SECRET_KEY'

source = Omise::Source.create({
  type: 'kakaopay',
  amount: 1000000,
  currency: 'KRW'
})

Go

source, err := client.Sources().Create(&operations.CreateSource{
    Type:     "kakaopay",
    Amount:   1000000,
    Currency: "KRW",
})

การตอบสนอง:

{
  "object": "source",
  "id": "src_test_5rt6s9vah5lkvi1rh9c",
  "type": "kakaopay",
  "flow": "redirect",
  "amount": 1000000,
  "currency": "KRW"
}

ขั้นตอนที่ 2: สร้าง Charge และเปลี่ยนเส้นทาง

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

        // Validate amount
        if (amount < 10000) {  // ₩100 minimum
            return res.status(400).json({
                error: 'Minimum amount is ₩100'
            });
        }

        if (amount > 1000000000) {  // ₩10,000,000 maximum
            return res.status(400).json({
                error: 'Maximum amount is ₩10,000,000'
            });
        }

        // Create source
        const source = await omise.sources.create({
            type: 'kakaopay',
            amount: amount,
            currency: 'KRW'
        });

        // Create charge
        const charge = await omise.charges.create({
            amount: amount,
            currency: 'KRW',
            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: 'kakaopay'
            }
        });

        // Redirect to KakaoPay
        res.redirect(charge.authorize_uri);

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

ขั้นตอนที่ 3: จัดการ Return 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') {
            await processOrder(charge.metadata.order_id);
            res.redirect(`/order-success?order=${charge.metadata.order_id}`);
        } else if (charge.status === 'failed') {
            res.redirect(`/payment-failed?reason=${charge.failure_message}`);
        } else {
            res.redirect('/payment-pending');
        }
    } catch (error) {
        res.redirect('/payment-error');
    }
});

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

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

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

        if (charge.source.type === 'kakaopay') {
            if (charge.status === 'successful') {
                await fulfillOrder(charge.metadata.order_id);
                await sendConfirmationEmail(charge.metadata.customer_email);
            } else if (charge.status === 'failed') {
                await handleFailedPayment(charge.metadata.order_id);
            }
        }
    }

    res.sendStatus(200);
});

ตัวอย่างการใช้งานที่สมบูรณ์

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

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

// KakaoPay configuration
const KAKAOPAY_CONFIG = {
    currency: 'KRW',
    minAmount: 10000,      // ₩100
    maxAmount: 1000000000, // ₩10,000,000
    displayName: 'KakaoPay',
    timeout: 10 * 60 * 1000 // 10 minutes
};

// Create KakaoPay payment
app.post('/checkout/kakaopay', async (req, res) => {
    try {
        const { amount, order_id, customer_email, customer_name, customer_phone } = req.body;

        // Validate currency
        if (req.body.currency && req.body.currency !== 'KRW') {
            return res.status(400).json({
                error: 'KakaoPay only supports KRW currency'
            });
        }

        // Validate amount
        if (amount < KAKAOPAY_CONFIG.minAmount) {
            return res.status(400).json({
                error: `Minimum amount is ₩${KAKAOPAY_CONFIG.minAmount / 100}`
            });
        }

        if (amount > KAKAOPAY_CONFIG.maxAmount) {
            return res.status(400).json({
                error: `Maximum amount is ₩${KAKAOPAY_CONFIG.maxAmount / 100}`
            });
        }

        // Create source
        const source = await omise.sources.create({
            type: 'kakaopay',
            amount: amount,
            currency: KAKAOPAY_CONFIG.currency
        });

        // Create charge
        const charge = await omise.charges.create({
            amount: amount,
            currency: KAKAOPAY_CONFIG.currency,
            source: source.id,
            return_uri: `${process.env.BASE_URL}/payment/callback`,
            metadata: {
                order_id: order_id,
                customer_email: customer_email,
                customer_name: customer_name,
                customer_phone: customer_phone,
                payment_method: 'kakaopay'
            }
        });

        // Log for tracking
        console.log(`KakaoPay payment initiated: ${charge.id} for order ${order_id}`);

        // Return authorization URL
        res.json({
            authorize_uri: charge.authorize_uri,
            charge_id: charge.id
        });

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

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

        if (charge.status === 'successful') {
            res.redirect(`/order-confirmation?order=${charge.metadata.order_id}`);
        } else {
            res.redirect(`/payment-failed?charge=${req.query.charge_id}`);
        }
    } catch (error) {
        res.redirect('/payment-error');
    }
});

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

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

        if (charge.status === 'successful') {
            await fulfillOrder(charge.metadata.order_id);
            await sendReceipt(charge.metadata.customer_email, charge);
            console.log(`KakaoPay payment successful: ${charge.id}`);
        } else {
            await cancelOrder(charge.metadata.order_id);
            console.log(`KakaoPay payment failed: ${charge.id}`);
        }
    }

    res.sendStatus(200);
});

app.listen(3000);

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

KakaoPay รองรับ การคืนเงินแบบเต็มและบางส่วน ภายใน 365 วัน:

// Full refund
const fullRefund = await omise.charges.refund('chrg_test_...', {
    amount: 1000000  // Full amount
});

// Partial refund
const partialRefund = await omise.charges.refund('chrg_test_...', {
    amount: 500000  // Partial amount
});

console.log('Refund status:', fullRefund.status);

การประมวลผล Refund

การคืนเงินจะประมวลผลกลับไปยังบัญชี KakaoPay ของลูกค้าภายใน 3-5 วันทำการ

ปัญหาทั่วไปและการแก้ไขปัญหา

ปัญหา: ลูกค้าไม่มี KakaoTalk

สาเหตุ: ลูกค้าไม่มีแอป KakaoTalk (หายากในเกาหลีใต้)

วิธีแก้ไข:

// Show KakaoTalk requirement
function checkKakaoTalk() {
    const isMobile = /iPhone|iPad|iPod|Android/i.test(navigator.userAgent);

    if (!isMobile) {
        alert('카카오페이는 모바일에서만 사용 가능합니다.');
        return false;
    }

    // Show app links
    const isAndroid = /Android/i.test(navigator.userAgent);
    const appLink = isAndroid
        ? 'https://play.google.com/store/apps/details?id=com.kakao.talk'
        : 'https://apps.apple.com/kr/app/kakaotalk/id362057947';

    showMessage(`카카오톡 앱이 필요합니다. <a href="${appLink}">다운로드</a>`);
    return true;
}

ปัญหา: วิธีการชำระเงินไม่ได้เชื่อมโยง

ข้อผิดพลาด: ไม่มีวิธีการชำระเงินที่เชื่อมโยงกับ KakaoPay

วิธีแก้ไข:

if (charge.failure_code === 'no_payment_method') {
    showMessage(
        '카카오페이에 결제수단이 등록되지 않았습니다. ' +
        '카카오톡에서 결제수단을 등록해주세요.'
    );
    showPaymentMethodSetupGuide();
}

ปัญหา: เกินขีดจำกัดธุรกรรม

ข้อผิดพลาด: ธุรกรรมเกินขีดจำกัดบัญชี

วิธีแก้ไข:

if (charge.failure_code === 'transaction_limit_exceeded') {
    showMessage(
        '거래 한도를 초과했습니다. ' +
        '본인 인증 후 한도를 늘리거나 다른 결제수단을 이용해주세요.'
    );
}

ปัญหา: หมดเวลาการชำระเงิน

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

วิธีแก้ไข:

const TIMEOUT = 10 * 60 * 1000;

setTimeout(() => {
    if (!paymentCompleted) {
        showMessage('결제 시간이 초과되었습니다. 다시 시도해주세요.');
        enableRetry();
    }
}, TIMEOUT);

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

1. แสดงผลเป็นภาษาเกาหลี

<div class="kakaopay-payment">
    <h3>카카오페이로 결제</h3>
    <div class="logo">
        <img src="/icons/kakaopay-logo.svg" alt="카카오페이">
    </div>
    <div class="instructions">
        <ol>
            <li>카카오톡 앱이 설치되어 있어야 합니다</li>
            <li>카카오페이에 결제수단이 등록되어 있어야 합니다</li>
            <li>카카오톡 앱으로 자동 이동합니다</li>
            <li>비밀번호 또는 생체인증으로 결제를 승인합니다</li>
        </ol>
    </div>
    <p class="help-text">
        카카오페이가 처음이신가요?
        <a href="https://www.kakaopay.com" target="_blank">자세히 보기</a>
    </p>
</div>

2. การตรวจจับมือถือเท่านั้น

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

    if (!isMobile) {
        return {
            valid: false,
            message: '카카오페이는 모바일 기기에서만 사용할 수 있습니다'
        };
    }

    return { valid: true };
}

3. จัดการ Deep Links

function openKakaoTalkApp(authorizeUri) {
    // Redirect to KakaoPay
    window.location = authorizeUri;

    // Fallback if app doesn't open
    setTimeout(() => {
        if (!document.hidden) {
            showKakaoTalkInstallPrompt();
        }
    }, 2000);
}

function showKakaoTalkInstallPrompt() {
    const isAndroid = /Android/i.test(navigator.userAgent);
    const downloadUrl = isAndroid
        ? 'https://play.google.com/store/apps/details?id=com.kakao.talk'
        : 'https://apps.apple.com/kr/app/kakaotalk/id362057947';

    if (confirm('카카오톡 앱이 설치되지 않았습니다. 다운로드 하시겠습니까?')) {
        window.location = downloadUrl;
    }
}

4. การจัดรูปแบบจำนวนเงิน

function formatKRW(amount) {
    return new Intl.NumberFormat('ko-KR', {
        style: 'currency',
        currency: 'KRW',
        minimumFractionDigits: 0,
        maximumFractionDigits: 0
    }).format(amount / 100);
}

// Usage
const displayAmount = formatKRW(1000000); // "₩10,000"

5. แสดงการตั้งค่าวิธีการชำระเงิน

<div class="kakaopay-setup-guide">
    <h4>카카오페이 결제수단 등록 방법:</h4>
    <ol>
        <li>카카오톡 앱 실행</li>
        <li>우측 하단 점 3개 메뉴 선택</li>
        <li>페이 선택</li>
        <li>결제 선택</li>
        <li>결제수단 관리</li>
        <li>카드, 계좌, 또는 페이머니 등록</li>
    </ol>
</div>

กรณีการใช้งาน

อีคอมเมิร์ซ

• ใช้งานได้ดีสำหรับการช้อปปิ้งออนไลน์ของเกาหลี
• อัตราการแปลงสูง
• ประสบการณ์ชำระเงินแบบรวดเร็ว

เนื้อหาดิจิทัล

• เพลง วิดีโอ หนังสือ
• รายการเกมและการสมัครสมาชิก
• การซื้อในแอป

การส่งอาหาร

• ชำระเงินอย่างรวดเร็วสำหรับคำสั่ง
• รวมเข้ากับแอปการส่ง
• ได้รับความนิยมสำหรับการชำระเงินที่ร้านอาหาร

บริการ

• การขนส่ง (แท็กซี่ รถโดยสาร ที่จอดรถ)
• การจัดสำหรับความสวยความงาม
• ตั๋วกิจกรรมและการจอง

การทดสอบ

ข้อมูลรับรองการทดสอบ

ใช้ข้อมูลรับรองโหมดทดสอบ Omise:

• Secret Key: skey_test_YOUR_SECRET_KEY
• Public Key: pkey_test_YOUR_PUBLIC_KEY

จำนวนเงินทดสอบ

จำนวนเงิน (KRW)	ผลลัพธ์ที่คาดไว้
10000 - 999999	สำเร็จ
1000000	เงินไม่เพียงพอ
1000001	ธุรกรรมถูกปฏิเสธ

การไหลของการทดสอบ

1. สร้าง charge ด้วยข้อมูลรับรองการทดสอบ
2. ใช้จำนวนเงินทดสอบข้างต้น
3. ทำการชำระเงินให้เสร็จสิ้นในสภาพแวดล้อมการทดสอบของ KakaoPay
4. ตรวจสอบว่า webhook ได้รับ
5. ตรวจสอบสถานะของ charge

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

KakaoPay คืออะไร?

KakaoPay เป็นกระเป๋าดิจิทัลชั้นนำของเกาหลีใต้ที่มีผู้ใช้กว่า 30 ล้านคน รวมเข้ากับ KakaoTalk โดยตรง ซึ่งเป็นแอปการส่งข้อความที่ได้รับความนิยมมากที่สุดในเกาหลีใต้ที่ใช้โดยเกาหลีใต้กว่า 90%

ลูกค้าต้องใช้ KakaoTalk หรือไม่?

ใช่ KakaoPay รวมเข้ากับ KakaoTalk ดังนั้นลูกค้าจึงต้องติดตั้งแอป KakaoTalk ซึ่งเป็นมาตรฐานในเกาหลีใต้ที่ KakaoTalk มีการเข้าถึง 90% ขึ้นไป

ข้อจำกัดของธุรกรรมคืออะไร?

• จำนวนต่ำสุด: ₩100
• จำนวนสูงสุด: ₩10,000,000 ต่อธุรกรรม

ขีดจำกัดขึ้นอยู่กับระดับการตรวจสอบบัญชีของลูกค้า (พื้นฐาน ยืนยัน บวก)

การชำระเงินใช้เวลานานเท่าใด?

การชำระเงิน KakaoPay โดยปกติจะเกิดขึ้นภายใน 1-3 วันทำการ ตรวจสอบแดชบอร์ด Omise ของคุณเพื่อดูตารางเวลาการชำระเงินที่เฉพาะเจาะจง

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

ใช่ KakaoPay รองรับการคืนเงินแบบเต็มและบางส่วนภายใน 365 วันนับจากธุรกรรมเดิม

ลูกค้าไม่มีวิธีการชำระเงินที่เชื่อมโยงจะเกิดอะไรขึ้น?

ลูกค้าต้องเพิ่มวิธีการชำระเงิน (บัตรเครดิต บัญชีธนาคาร หรือ Kakao Money) ใน KakaoTalk ก่อนที่พวกเขาจะสามารถใช้ KakaoPay ได้ โปรดอ้างอิงพวกเขาไปยังการตั้งค่า KakaoTalk เพื่อเพิ่มวิธีการชำระเงิน

KakaoPay ทำงานบนเดสก์ท็อปหรือไม่?

ไม่ KakaoPay ต้องใช้แอปมือถือ KakaoTalk ผู้ใช้เดสก์ท็อปควรแสดงวิธีการชำระเงินอื่น ๆ เช่นบัตรเครดิตหรือการโอนธนาคาร

ฉันควรแสดงคำแนะนำเป็นภาษาเกาหลีหรือไม่?

ใช่! เนื่องจาก KakaoPay นั้นเฉพาะเจาะจงกับเกาหลีใต้ การแสดงคำแนะนำและข้อความทั้งหมดเป็นภาษาเกาหลี (한국어) จึงเป็นสิ่งสำคัญสำหรับประสบการณ์ผู้ใช้ที่ดีที่สุด

การทดสอบ

โหมดการทดสอบ

สามารถทดสอบ KakaoPay ได้โดยใช้คีย์ API ทดสอบของคุณ ในโหมดทดสอบ:

ข้อมูลรับรองการทดสอบ:

• ใช้คีย์ API ทดสอบ (skey_test_xxx)
• สกุลเงิน: KRW (วอนเกาหลีใต้)
• ไม่จำเป็นต้องมีบัญชี KakaoPay จริงสำหรับการทดสอบ

การไหลของการทดสอบ:

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

การใช้งานการทดสอบ:

// Test KakaoPay payment
const source = await omise.sources.create({
    type: 'kakaopay',
    amount: 10000,  // ₩10,000
    currency: 'KRW'
});

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

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

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

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

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

• โหมดทดสอบไม่เชื่อมต่อกับเซิร์ฟเวอร์ KakaoPay จริง
• ใช้แดชบอร์ดเพื่อจำลองผลลัพธ์การชำระเงิน
• ทดสอบการไหลแอปมือถือ (การรวม KakaoTalk)
• ตรวจสอบการจัดการ webhook สำหรับสถานะ charge ทั้งหมด
• ทดสอบการตรวจสอบจำนวนเงินสำหรับสกุลเงิน KRW

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

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

• ภาพรวมกระเป๋าดิจิทัล - ตัวเลือกกระเป๋าทั้งหมด
• Alipay+ - KakaoPay ผ่านเครือข่าย Alipay+
• PayPay - กระเป๋าที่คล้ายกันของญี่ปุ่น
• การชำระเงิน QR - การชำระเงินบนมือถือทางเลือก
• การคืนเงิน - นโยบายการคืนเงิน
• การทดสอบ - ทดสอบการรวม KakaoPay
• Webhooks - ใช้งาน webhooks

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

1. สร้าง KakaoPay source
2. ใช้งานการไหลแบบเปลี่ยนเส้นทาง
3. จัดการ return callback
4. ตั้งค่า webhook
5. ทดสอบการไหลของการชำระเงิน
6. ลงสู่การผลิต