วิธีใช้ iPay API เชื่อมต่อระบบชำระเงิน ปี 2026

สรุปแบบย่อ

iPay API ช่วยให้นักพัฒนาสามารถผสานรวมการประมวลผลการชำระเงิน การออกใบแจ้งหนี้ และการทำธุรกรรมทางการเงินเข้ากับระบบได้ด้วยโปรแกรม โดยใช้การยืนยันตัวตนด้วย OAuth 2.0 และ API key มี RESTful endpoints สำหรับการชำระเงิน การคืนเงิน การทำธุรกรรม และการกระทบยอด พร้อมข้อกำหนดการปฏิบัติตาม PCI DSS และขีดจำกัดอัตรามาตรฐานอุตสาหกรรม คู่มือนี้ครอบคลุมการตั้งค่าการยืนยันตัวตน การประมวลผลการชำระเงิน การผสานรวม Webhook การปฏิบัติตามข้อกำหนดด้านความปลอดภัย และกลยุทธ์การปรับใช้ในสภาพแวดล้อมจริง

บทนำ

การประมวลผลการชำระเงินดิจิทัลทั่วโลกมีมูลค่ากว่า 8 ล้านล้านดอลลาร์ต่อปี สำหรับนักพัฒนาที่สร้างแพลตฟอร์มอีคอมเมิร์ซ แอปพลิเคชัน SaaS หรือโซลูชันตลาดกลาง การผสานรวม Payment API ไม่ใช่ทางเลือก แต่เป็นสิ่งจำเป็นสำหรับการรับชำระเงินจากลูกค้าอย่างปลอดภัยและเป็นไปตามข้อกำหนด

ความเป็นจริงคือ ธุรกิจสูญเสียรายได้ 5-10% จากการชำระเงินที่ไม่สำเร็จ การกระทบยอดด้วยตนเอง และการฉ้อโกงการชำระเงิน การผสานรวม Payment API ที่แข็งแกร่งจะช่วยให้การประมวลผลการชำระเงินเป็นไปโดยอัตโนมัติ ลดความล้มเหลวด้วยตรรกะการลองใหม่ที่ชาญฉลาด เปิดใช้งานการกระทบยอดอัตโนมัติ และนำการตรวจจับการฉ้อโกงมาใช้

คู่มือนี้จะนำคุณไปสู่กระบวนการผสานรวม Payment API ที่สมบูรณ์ คุณจะได้เรียนรู้การตั้งค่าการยืนยันตัวตน การประมวลผลการชำระเงิน การจัดการการคืนเงิน การจัดการ Webhook การปฏิบัติตามข้อกำหนด PCI DSS แนวทางปฏิบัติที่ดีที่สุดด้านความปลอดภัย และกลยุทธ์การปรับใช้ในสภาพแวดล้อมจริง เมื่อจบคู่มือนี้ คุณจะมีการผสานรวมการชำระเงินที่พร้อมใช้งานจริง

หมายเหตุ: คู่มือนี้ครอบคลุมรูปแบบการผสานรวม Payment API ทั่วไปที่ใช้ได้กับ iPay และผู้ประมวลผลการชำระเงินที่คล้ายกัน รายละเอียด URL ของ endpoint และการยืนยันตัวตนเฉพาะอาจแตกต่างกันไป โปรดอ้างอิงเอกสารอย่างเป็นทางการของ iPay สำหรับรายละเอียดการใช้งานเสมอ

iPay API คืออะไร?

Payment API เช่น iPay มีอินเทอร์เฟซ RESTful สำหรับการประมวลผลธุรกรรมทางการเงิน API จัดการสิ่งเหล่านี้:

• การอนุมัติและการเรียกเก็บเงิน
• การคืนเงินและการปฏิเสธการชำระเงิน (Chargebacks)
• ประวัติการทำธุรกรรมและการรายงาน
• การสร้างโทเคนลูกค้า (การจัดเก็บข้อมูลบัตรอย่างปลอดภัย)
• การสมัครสมาชิกและการเรียกเก็บเงินแบบประจำ
• การสร้างและการจัดการใบแจ้งหนี้
• การกระทบยอดและการชำระเงิน
• การตรวจจับและป้องกันการฉ้อโกง

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

ภาพรวมขั้นตอนการชำระเงิน

┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   Customer  │───▶│   Merchant  │───▶│  Payment    │
│   (Browser) │    │   (Server)  │    │  Gateway    │
└─────────────┘    └─────────────┘    └─────────────┘
     │                    │                    │
     │  1. Enter Card     │                    │
     │───────────────────▶│                    │
     │                    │                    │
     │  2. Tokenize       │                    │
     │───────────────────▶│  3. Create Intent  │
     │                    │───────────────────▶│
     │                    │                    │
     │                    │  4. Confirm Payment│
     │                    │───────────────────▶│
     │                    │                    │
     │                    │  5. Result         │
     │                    │◀───────────────────│
     │                    │                    │
     │  6. Receipt        │                    │
     │◀───────────────────│                    │

สภาพแวดล้อม API

เริ่มต้นใช้งาน: การตั้งค่าการยืนยันตัวตน

ขั้นตอนที่ 1: สร้างบัญชี iPay

ก่อนเข้าถึง API:

1. เข้าไปที่หน้าการลงทะเบียนผู้ค้าของ iPay
2. ดำเนินการยืนยันตัวตนทางธุรกิจให้สมบูรณ์ (KYB)
3. ส่งเอกสารที่จำเป็น:

• หนังสือรับรองการจดทะเบียนธุรกิจ
• รายละเอียดบัญชีธนาคาร
• บัตรประจำตัวที่ออกโดยรัฐบาล

1. รอการอนุมัติ (1-3 วันทำการ)

ขั้นตอนที่ 2: รับข้อมูลรับรอง API

สร้างข้อมูลรับรอง API:

1. เข้าสู่ระบบ iPay Merchant Dashboard
2. ไปที่ การตั้งค่า > API Keys
3. สร้าง API key ใหม่
4. คัดลอกข้อมูลรับรองอย่างปลอดภัย

# ไฟล์ .env (ห้าม commit เข้า git เด็ดขาด)
IPAY_API_KEY="live_xxxxxxxxxxxxxxxxxxxx"
IPAY_API_SECRET="secret_xxxxxxxxxxxxxxxxxxxx"
IPAY_WEBHOOK_SECRET="whsec_xxxxxxxxxxxxxxxxxxxx"

ข้อควรทราบด้านความปลอดภัย: ใช้คีย์แยกกันสำหรับ Sandbox และ Production

ขั้นตอนที่ 3: ทำความเข้าใจวิธีการยืนยันตัวตน

iPay รองรับวิธีการยืนยันตัวตนหลายวิธี:

ขั้นตอนที่ 4: เรียกใช้ API ที่มีการยืนยันตัวตน

สร้าง API client ที่นำกลับมาใช้ใหม่ได้:

const IPAY_BASE_URL = process.env.IPAY_SANDBOX
  ? 'https://sandbox.ipay.com/api'
  : 'https://api.ipay.com/api';

const ipayRequest = async (endpoint, options = {}) => {
  const apiKey = process.env.IPAY_API_KEY;
  const apiSecret = process.env.IPAY_API_SECRET;

  // การยืนยันตัวตนแบบ Basic (เข้ารหัส Base64)
  const authHeader = Buffer.from(`${apiKey}:${apiSecret}`).toString('base64');

  const response = await fetch(`${IPAY_BASE_URL}${endpoint}`, {
    ...options,
    headers: {
      'Authorization': `Basic ${authHeader}`,
      'Content-Type': 'application/json',
      'Idempotency-Key': options.idempotencyKey || generateIdempotencyKey(),
      ...options.headers
    }
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`iPay API Error: ${error.message}`);
  }

  return response.json();
};

function generateIdempotencyKey() {
  return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
}

// การใช้งาน
const account = await ipayRequest('/account');
console.log(`ผู้ค้า: ${account.business_name}`);

การประมวลผลการชำระเงิน

การสร้าง Payment Intent

เริ่มต้นการชำระเงิน:

const createPayment = async (paymentData) => {
  const payment = {
    amount: paymentData.amount, // ในหน่วยสกุลเงินที่เล็กที่สุด (เซ็นต์)
    currency: paymentData.currency || 'USD',
    customer: paymentData.customerId,
    payment_method: paymentData.paymentMethodId,
    confirm: true,
    description: paymentData.description,
    metadata: {
      orderId: paymentData.orderId,
      customerId: paymentData.customerId
    },
    capture_method: paymentData.captureMethod || 'automatic', // 'automatic' หรือ 'manual'
    statement_descriptor: paymentData.statementDescriptor || 'MYCOMPANY'
  };

  const response = await ipayRequest('/payments', {
    method: 'POST',
    body: JSON.stringify(payment),
    idempotencyKey: paymentData.idempotencyKey
  });

  return response;
};

// การใช้งาน
const payment = await createPayment({
  amount: 2999, // $29.99
  currency: 'USD',
  customerId: 'cus_12345',
  paymentMethodId: 'pm_67890',
  description: 'Order #ORD-001',
  orderId: 'ORD-001',
  statementDescriptor: 'MYCOMPANY INC'
});

console.log(`สถานะการชำระเงิน: ${payment.status}`);
console.log(`รหัสการชำระเงิน: ${payment.id}`);

แผนผังสถานะการชำระเงิน

requires_payment_method → requires_confirmation → requires_action
                         → processing → requires_capture → succeeded
                                                        → failed
                                                        → canceled

วิธีการชำระเงิน

การสร้างโทเคนข้อมูลบัตร

จัดเก็บข้อมูลบัตรอย่างปลอดภัยเพื่อการใช้งานในอนาคต:

const tokenizeCard = async (cardData) => {
  // ห้ามส่งข้อมูลบัตรดิบไปยังเซิร์ฟเวอร์ของคุณเด็ดขาด
  // ให้ใช้การสร้างโทเคนฝั่งไคลเอนต์แทน

  // ฝั่งไคลเอนต์ (เบราว์เซอร์/มือถือ)
  const response = await fetch(`${IPAY_BASE_URL}/tokens`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${CLIENT_PUBLISHABLE_KEY}`
    },
    body: JSON.stringify({
      card: {
        number: cardData.number,
        exp_month: cardData.expMonth,
        exp_year: cardData.expYear,
        cvc: cardData.cvc
      }
    })
  });

  const token = await response.json();
  return token; // ส่ง token.id ไปยังเซิร์ฟเวอร์ของคุณ
};

// ฝั่งเซิร์ฟเวอร์: ใช้โทเคนเพื่อสร้างวิธีการชำระเงิน
const createPaymentMethod = async (tokenId, customerId) => {
  const response = await ipayRequest('/payment_methods', {
    method: 'POST',
    body: JSON.stringify({
      type: 'card',
      token: tokenId,
      customer: customerId
    })
  });

  return response;
};

การยืนยันตัวตน 3D Secure

ใช้การปฏิบัติตามข้อกำหนด SCA:

const createPaymentWith3DS = async (paymentData) => {
  const payment = await createPayment({
    ...paymentData,
    confirmation_token: true // ส่งคืน client secret สำหรับ 3DS
  });

  if (payment.status === 'requires_action') {
    // ไคลเอนต์ต้องทำตามขั้นตอนการยืนยันตัวตน 3DS
    return {
      requiresAction: true,
      clientSecret: payment.client_secret,
      nextAction: payment.next_action
    };
  }

  return { success: true, payment };
};

// ฝั่งไคลเอนต์: จัดการการยืนยันตัวตน 3DS
// ใช้ iPay.js หรือ mobile SDK เพื่อแสดงหน้าการยืนยันตัวตน

การจัดการการคืนเงิน

การประมวลผลการคืนเงินเต็มจำนวน

คืนเงินจากการชำระเงินทั้งหมด:

const refundPayment = async (paymentId, reason = null) => {
  const refund = {
    payment: paymentId,
    reason: reason || 'requested_by_customer'
  };

  const response = await ipayRequest('/refunds', {
    method: 'POST',
    body: JSON.stringify(refund),
    idempotencyKey: `refund_${paymentId}_${Date.now()}`
  });

  return response;
};

// การใช้งาน
const refund = await refundPayment('pay_12345', 'duplicate');
console.log(`สถานะการคืนเงิน: ${refund.status}`);
console.log(`รหัสการคืนเงิน: ${refund.id}`);

การประมวลผลการคืนเงินบางส่วน

คืนเงินบางส่วนจากการชำระเงิน:

const partialRefund = async (paymentId, amount, reason = null) => {
  const refund = {
    payment: paymentId,
    amount: amount, // ในหน่วยสกุลเงินที่เล็กที่สุด
    reason: reason || 'requested_by_customer'
  };

  const response = await ipayRequest('/refunds', {
    method: 'POST',
    body: JSON.stringify(refund),
    idempotencyKey: `refund_${paymentId}_${amount}_${Date.now()}`
  });

  return response;
};

// การใช้งาน - คืนเงิน $15.00 จากการชำระเงิน $29.99
const refund = await partialRefund('pay_12345', 1500, 'partial_ship');
console.log(`คืนเงิน: $${refund.amount / 100}`);

เหตุผลในการคืนเงิน

การจัดการลูกค้า

การสร้างลูกค้า

จัดเก็บข้อมูลลูกค้าสำหรับการชำระเงินแบบประจำ:

const createCustomer = async (customerData) => {
  const customer = {
    email: customerData.email,
    name: customerData.name,
    phone: customerData.phone,
    metadata: {
      internalId: customerData.internalId,
      tier: customerData.tier
    }
  };

  const response = await ipayRequest('/customers', {
    method: 'POST',
    body: JSON.stringify(customer)
  });

  return response;
};

// การใช้งาน
const customer = await createCustomer({
  email: 'customer@example.com',
  name: 'John Doe',
  phone: '+1-555-0123',
  internalId: 'USR-12345',
  tier: 'premium'
});

console.log(`สร้างลูกค้าแล้ว: ${customer.id}`);

การผูกวิธีการชำระเงินกับลูกค้า

บันทึกบัตรเพื่อใช้ในอนาคต:

const attachPaymentMethod = async (paymentMethodId, customerId) => {
  const response = await ipayRequest(`/payment_methods/${paymentMethodId}/attach`, {
    method: 'POST',
    body: JSON.stringify({
      customer: customerId
    })
  });

  return response;
};

// การใช้งาน
await attachPaymentMethod('pm_67890', 'cus_12345');

การแสดงรายการวิธีการชำระเงินของลูกค้า

ดึงข้อมูลบัตรที่บันทึกไว้:

const getCustomerPaymentMethods = async (customerId) => {
  const response = await ipayRequest(`/customers/${customerId}/payment_methods`);
  return response;
};

// การใช้งาน
const methods = await getCustomerPaymentMethods('cus_12345');
methods.data.forEach(method => {
  console.log(`${method.card.brand} ลงท้ายด้วย ${method.card.last4}`);
  console.log(`หมดอายุ: ${method.card.exp_month}/${method.card.exp_year}`);
});

Webhooks

การกำหนดค่า Webhooks

ตั้งค่า webhook endpoints:

1. เข้าสู่ระบบ iPay Dashboard
2. ไปที่ นักพัฒนา > Webhooks
3. คลิก เพิ่ม Endpoint
4. ป้อน URL แบบ HTTPS ของคุณ
5. เลือกเหตุการณ์ที่ต้องการสมัครรับ

เหตุการณ์ Webhook

การจัดการ Webhooks

const express = require('express');
const crypto = require('crypto');
const app = express();

app.post('/webhooks/ipay', express.raw({ type: 'application/json' }), async (req, res) => {
  const signature = req.headers['ipay-signature'];
  const payload = req.body;

  // ตรวจสอบลายเซ็น Webhook
  const isValid = verifyWebhookSignature(payload, signature, process.env.IPAY_WEBHOOK_SECRET);

  if (!isValid) {
    console.error('ลายเซ็น Webhook ไม่ถูกต้อง');
    return res.status(401).send('ไม่ได้รับอนุญาต');
  }

  const event = JSON.parse(payload.toString());

  // ส่งต่อไปยังตัวจัดการที่เหมาะสม
  switch (event.type) {
    case 'payment.succeeded':
      await handlePaymentSucceeded(event.data);
      break;
    case 'payment.failed':
      await handlePaymentFailed(event.data);
      break;
    case 'payment.refunded':
      await handlePaymentRefunded(event.data);
      break;
    case 'payment.disputed':
      await handlePaymentDisputed(event.data);
      break;
    default:
      console.log('ประเภทเหตุการณ์ที่ไม่ได้จัดการ:', event.type);
  }

  // ยืนยันการรับ
  res.status(200).send('OK');
});

function verifyWebhookSignature(payload, signature, secret) {
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(signature, 'hex'),
    Buffer.from(expectedSignature, 'hex')
  );
}

async function handlePaymentSucceeded(data) {
  console.log(`การชำระเงินสำเร็จ: ${data.id}`);

  // อัปเดตสถานะคำสั่งซื้อ
  await db.orders.update(data.metadata.orderId, {
    status: 'paid',
    paymentId: data.id,
    paidAt: new Date()
  });

  // ส่งอีเมลยืนยัน
  await sendOrderConfirmation(data.metadata.orderId);
}

async function handlePaymentFailed(data) {
  console.log(`การชำระเงินล้มเหลว: ${data.id} - ${data.failure_code}`);

  // แจ้งลูกค้า
  await sendPaymentFailedEmail(data.customer, data.failure_message);

  // ตรรกะการลองใหม่หรือทำเครื่องหมายคำสั่งซื้อว่าล้มเหลว
  await db.orders.update(data.metadata.orderId, {
    status: 'payment_failed',
    failureReason: data.failure_message
  });
}

ความปลอดภัยและการปฏิบัติตามข้อกำหนด

ข้อกำหนด PCI DSS

การผสานรวมการชำระเงินต้องเป็นไปตาม PCI DSS:

แนวทางปฏิบัติที่ดีที่สุดด้านความปลอดภัย

// 1. ใช้การสร้างโทเคน - ห้ามจัดการข้อมูลบัตรดิบเด็ดขาด
const token = await tokenizeCard(cardData); // ฝั่งไคลเอนต์

// 2. ใช้ idempotency สำหรับการดำเนินการชำระเงินทั้งหมด
const idempotencyKey = `pay_${orderId}_${Date.now()}`;

// 3. ตรวจสอบความถูกต้องของยอดเงินฝั่งเซิร์ฟเวอร์
if (req.body.amount !== calculatedAmount) {
  throw new Error('ยอดเงินไม่ตรงกัน - อาจมีการปลอมแปลง');
}

// 4. บันทึกการดำเนินการชำระเงินทั้งหมด (โดยไม่มีข้อมูลที่ละเอียดอ่อน)
logger.info('Payment attempted', {
  orderId,
  amount,
  currency,
  customerId,
  timestamp: new Date().toISOString()
  // ห้ามบันทึก: หมายเลขบัตร, CVV, รายละเอียดวิธีการชำระเงินทั้งหมด
});

// 5. ใช้ตัวแปรสภาพแวดล้อมสำหรับข้อมูลลับ
const apiKey = process.env.IPAY_API_KEY; // ไม่ได้เขียนโค้ดฝังไว้

// 6. ใช้การจำกัดอัตรา (rate limiting) บน payment endpoints
const paymentLimiter = rateLimit({
  windowMs: 60000,
  max: 10 // พยายามชำระเงิน 10 ครั้งต่อนาที
});

รายการตรวจสอบการปรับใช้ในสภาพแวดล้อมจริง

ก่อนประมวลผลการชำระเงินจริง:

• [ ] กรอกแบบสอบถามการประเมินตนเอง PCI DSS
• [ ] ใช้ HTTPS สำหรับ endpoints ทั้งหมด
• [ ] จัดเก็บ API keys ในระบบจัดการความลับที่ปลอดภัย
• [ ] ใช้การตรวจสอบลายเซ็น Webhook
• [ ] เพิ่ม idempotency สำหรับการดำเนินการชำระเงินทั้งหมด
• [ ] ตั้งค่าการบันทึกข้อมูลอย่างครอบคลุม (โดยไม่มีข้อมูลที่ละเอียดอ่อน)
• [ ] กำหนดค่ากฎการตรวจจับการฉ้อโกง
• [ ] ทดสอบขั้นตอนการคืนเงินและการระงับข้อพิพาท
• [ ] สร้างคู่มือปฏิบัติการสำหรับความล้มเหลวในการชำระเงิน
• [ ] ตั้งค่าการเฝ้าระวังและการแจ้งเตือน
• [ ] ใช้งานผู้ประมวลผลการชำระเงินสำรอง

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

การชำระเงินของอีคอมเมิร์ซ

ผู้ค้าปลีกออนไลน์ผสานรวมการชำระเงิน:

• ความท้าทาย: การประมวลผลการชำระเงินด้วยตนเอง, อัตราการละทิ้งสูง
• โซลูชัน: การชำระเงินหน้าเดียวพร้อมบัตรที่สร้างโทเคน
• ผลลัพธ์: อัตราการเปลี่ยนเป็นลูกค้าเพิ่มขึ้น 35%, การชำระเงินทันที

การเรียกเก็บเงินค่าสมัครสมาชิก SaaS

บริษัทซอฟต์แวร์ทำให้การเรียกเก็บเงินเป็นไปโดยอัตโนมัติ:

• ความท้าทาย: การสร้างใบแจ้งหนี้และการเรียกเก็บเงินด้วยตนเอง
• โซลูชัน: การชำระเงินแบบประจำพร้อมการลองใหม่โดยอัตโนมัติ
• ผลลัพธ์: ชำระเงินตรงเวลา 95%, ประหยัดเวลาผู้ดูแลระบบ 80%

Escrow ของตลาดกลาง

แพลตฟอร์มจัดการการชำระเงินหลายฝ่าย:

• ความท้าทาย: การแบ่งการชำระเงินที่ซับซ้อนระหว่างผู้ขาย
• โซลูชัน: Payment intents พร้อมการกำหนดเวลาโอนเงิน
• ผลลัพธ์: การจ่ายเงินให้ผู้ขายอัตโนมัติ, ลดการฉ้อโกง

บทสรุป

การผสานรวม Payment API ต้องใส่ใจอย่างรอบคอบในเรื่องความปลอดภัย การปฏิบัติตามข้อกำหนด และการจัดการข้อผิดพลาด ประเด็นสำคัญ:

• ห้ามจัดการข้อมูลบัตรดิบเด็ดขาด—ให้ใช้การสร้างโทเคน
• ใช้ idempotency สำหรับการดำเนินการชำระเงินทั้งหมด
• ตรวจสอบลายเซ็น Webhook เพื่อป้องกันการฉ้อโกง
• ปฏิบัติตามข้อกำหนด PCI DSS
• ทดสอบอย่างละเอียดในโหมด Sandbox ก่อนปรับใช้จริง
• Apidog ช่วยให้การทดสอบ API และการทำงานร่วมกันเป็นทีมง่ายขึ้น

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

ฉันจะยืนยันตัวตนกับ iPay API ได้อย่างไร?

ใช้การยืนยันตัวตนแบบ Basic ด้วย API key และ secret หรือ OAuth 2.0 สำหรับแอปพลิเคชันแบบ Multi-tenant

ฉันสามารถจัดเก็บรายละเอียดบัตรของลูกค้าได้หรือไม่?

ได้ แต่คุณต้องปฏิบัติตามข้อกำหนด PCI DSS ใช้การสร้างโทเคนเพื่อจัดเก็บข้อมูลบัตรอย่างปลอดภัยในระบบจัดเก็บข้อมูลของ iPay

ฉันจะจัดการกับการชำระเงินที่ล้มเหลวได้อย่างไร?

ใช้ตรรกะการลองใหม่ด้วย exponential backoff แจ้งลูกค้า และเสนอวิธีการชำระเงินทางเลือก

Idempotency คืออะไร และทำไมจึงสำคัญ?

Idempotency ช่วยให้มั่นใจว่าคำขอที่ซ้ำกันซึ่งใช้คีย์เดียวกันจะให้ผลลัพธ์เหมือนกัน เพื่อป้องกันการเรียกเก็บเงินซ้ำ

ฉันจะทดสอบการชำระเงินโดยไม่ต้องเรียกเก็บเงินจากบัตรได้อย่างไร?

ใช้โหมด Sandbox โดยใช้หมายเลขบัตรทดสอบที่ระบุไว้ในเอกสารของ iPay

Webhook signatures คืออะไร?

ลายเซ็นการเข้ารหัสที่ตรวจสอบว่า Webhooks มาจาก iPay ไม่ใช่จากผู้ไม่หวังดี