วิธีการชำระเงินที่บันทึกไว้

เรียนรู้วิธีการบันทึกและจัดการวิธีการชำระเงินอย่างปลอดภัยสำหรับการเรียกเก็บเงินแบบวนซ้ำ ประสบการณ์การจ่ายแบบคลิกเดียว และบริการสมาชิกซื้อ คู่มือนี้ครอบคลุมการเก็บบัตร การจัดการ และการเรียกเก็บเงินจากวิธีการชำระเงินที่บันทึกไว้

ภาพรวม

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

• การเรียกเก็บเงินสมาชิกซื้อแบบวนซ้ำ
• ประสบการณ์การจ่ายแบบคลิกเดียว
• บริการการต่ออายุอัตโนมัติ
• แพลตฟอร์มสมาชิกซื้อ
• การเรียกเก็บเงินตามการใช้งาน

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

• ปรับปรุงการแปลง - ลดแรงเสียดทานด้วยการชำระเงินแบบคลิกเดียว
• การเก็บรักษากลุ่มลูกค้าที่ดีขึ้น - การต่ออายุสมาชิกซื้อที่ราบรื่น
• ลดขอบเขต PCI - Tokens แทนข้อมูลบัตรดิบ
• ตัวเลือกการชำระเงินหลายรูปแบบ - รองรับบัตรที่บันทึกไว้หลายใบ
• ความปลอดภัยที่เพิ่มขึ้น - 3D Secure ในการใช้ครั้งแรก การเรียกเก็บเงินครั้งต่อไปเร็วขึ้น

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

Omise จัดการการเก็บบัตรอย่างปลอดภัย:

• บัตรถูก tokenized และเข้ารหัส
• โครงสร้างพื้นฐาน PCI DSS ระดับ 1 ที่ปฏิบัติตามข้อกำหนด
• ไม่มีข้อมูลบัตรดิบแตะเซิร์ฟเวอร์ของคุณ
• ระบบเก็บรักษาบัตรที่ปลอดภัย
• การปฏิบัติตามข้อกำหนดการป้องกันข้อมูล

การบันทึกวิธีการชำระเงิน

บันทึกบัตรพร้อมการสร้างลูกค้า

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

// Create customer with card
const customer = await omise.customers.create({
  email: 'john@example.com',
  description: 'John Doe',
  card: 'tokn_test_123456' // Token from client-side
});

console.log('Customer ID:', customer.id);
console.log('Default Card:', customer.default_card);

import omise

omise.api_secret = 'skey_test_123'

# Create customer with card
customer = omise.Customer.create(
    email='john@example.com',
    description='John Doe',
    card='tokn_test_123456'
)

print(f'Customer ID: {customer.id}')
print(f'Default Card: {customer.default_card}')

<?php
$omise = new Omise(['secretKey' => 'skey_test_123']);

$customer = $omise['customers']->create([
    'email' => 'john@example.com',
    'description' => 'John Doe',
    'card' => 'tokn_test_123456'
]);

echo "Customer ID: " . $customer['id'] . "\n";
echo "Default Card: " . $customer['default_card'];

curl https://api.omise.co/customers \
  -u skey_test_123: \
  -d "email=john@example.com" \
  -d "description=John Doe" \
  -d "card=tokn_test_123456"

เพิ่มบัตรให้กับลูกค้าที่มีอยู่

// Add additional card
await omise.customers.update('cust_test_123456', {
  card: 'tokn_test_new_card'
});

// Retrieve updated customer
const customer = await omise.customers.retrieve('cust_test_123456');
console.log(`Total cards: ${customer.cards.total}`);
console.log('Cards:', customer.cards.data.map(c =>
  `${c.brand} •••• ${c.last_digits}`
));

# Add additional card
customer = omise.Customer.retrieve('cust_test_123456')
customer.update(card='tokn_test_new_card')

# Retrieve updated customer
customer.reload()
print(f'Total cards: {customer.cards.total}')

for card in customer.cards.data:
    print(f'{card.brand} •••• {card.last_digits}')

curl https://api.omise.co/customers/cust_test_123456 \
  -u skey_test_123: \
  -d "card=tokn_test_new_card"

ขั้นตอนการบันทึกบัตรฝั่งไคลเอนต์

// Frontend: Create token
async function saveCard() {
  const cardData = {
    name: document.getElementById('name').value,
    number: document.getElementById('number').value,
    expiration_month: document.getElementById('month').value,
    expiration_year: document.getElementById('year').value,
    security_code: document.getElementById('cvv').value
  };

  // Create token
  const token = await Omise.createToken('card', cardData);

  // Send token to backend
  const response = await fetch('/api/save-card', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      token: token.id,
      customerId: 'cust_test_123456'
    })
  });

  return response.json();
}

// Backend: Save card to customer
app.post('/api/save-card', async (req, res) => {
  try {
    const { token, customerId } = req.body;

    const customer = await omise.customers.update(customerId, {
      card: token
    });

    res.json({
      success: true,
      cardId: customer.cards.data[0].id
    });
  } catch (error) {
    res.status(400).json({
      success: false,
      error: error.message
    });
  }
});

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

รายการบัตรที่บันทึกไว้

const customer = await omise.customers.retrieve('cust_test_123456');

customer.cards.data.forEach(card => {
  console.log(`Card ID: ${card.id}`);
  console.log(`Brand: ${card.brand}`);
  console.log(`Last 4: ${card.last_digits}`);
  console.log(`Expires: ${card.expiration_month}/${card.expiration_year}`);
  console.log(`Default: ${card.id === customer.default_card}`);
  console.log('---');
});

customer = omise.Customer.retrieve('cust_test_123456')

for card in customer.cards.data:
    print(f'Card ID: {card.id}')
    print(f'Brand: {card.brand}')
    print(f'Last 4: {card.last_digits}')
    print(f'Expires: {card.expiration_month}/{card.expiration_year}')
    print(f'Default: {card.id == customer.default_card}')
    print('---')

ตั้งค่าบัตรเริ่มต้น

// Change default card
await omise.customers.update('cust_test_123456', {
  default_card: 'card_test_789012'
});

// Verify change
const customer = await omise.customers.retrieve('cust_test_123456');
console.log('New default:', customer.default_card);

# Change default card
customer = omise.Customer.retrieve('cust_test_123456')
customer.update(default_card='card_test_789012')

# Verify change
customer.reload()
print(f'New default: {customer.default_card}')

curl https://api.omise.co/customers/cust_test_123456 \
  -u skey_test_123: \
  -d "default_card=card_test_789012"

นำบัตรออก

// Delete specific card
await omise.customers.destroyCard('cust_test_123456', 'card_test_789012');

// Verify removal
const customer = await omise.customers.retrieve('cust_test_123456');
console.log(`Remaining cards: ${customer.cards.total}`);

# Delete specific card
customer = omise.Customer.retrieve('cust_test_123456')
customer.destroy_card('card_test_789012')

# Verify removal
customer.reload()
print(f'Remaining cards: {customer.cards.total}')

curl https://api.omise.co/customers/cust_test_123456/cards/card_test_789012 \
  -u skey_test_123: \
  -X DELETE

ดึงข้อมูลบัตรเฉพาะ

// Get card details
const customer = await omise.customers.retrieve('cust_test_123456');
const card = customer.cards.data.find(c => c.id === 'card_test_789012');

console.log({
  id: card.id,
  brand: card.brand,
  lastDigits: card.last_digits,
  expiry: `${card.expiration_month}/${card.expiration_year}`,
  name: card.name,
  fingerprint: card.fingerprint
});

curl https://api.omise.co/customers/cust_test_123456/cards/card_test_789012 \
  -u skey_test_123:

การเรียกเก็บเงินจากวิธีการชำระเงินที่บันทึกไว้

เรียกเก็บเงินจากบัตรเริ่มต้น

// Charge customer's default card
const charge = await omise.charges.create({
  customer: 'cust_test_123456',
  amount: 100000, // 1,000.00 THB
  currency: 'THB',
  description: 'Monthly subscription - January 2024'
});

console.log('Charge status:', charge.status);
console.log('Card used:', charge.card.last_digits);

# Charge customer's default card
charge = omise.Charge.create(
    customer='cust_test_123456',
    amount=100000,
    currency='THB',
    description='Monthly subscription - January 2024'
)

print(f'Charge status: {charge.status}')
print(f'Card used: {charge.card.last_digits}')

เรียกเก็บเงินจากบัตรเฉพาะ

// Charge a specific saved card
const charge = await omise.charges.create({
  customer: 'cust_test_123456',
  card: 'card_test_789012',
  amount: 100000,
  currency: 'THB',
  description: 'Purchase with backup card'
});

# Charge a specific saved card
charge = omise.Charge.create(
    customer='cust_test_123456',
    card='card_test_789012',
    amount=100000,
    currency='THB',
    description='Purchase with backup card'
)

การเรียกเก็บเงินโดยไม่ใช้ CVV

// Saved cards don't require CVV for subsequent charges
const charge = await omise.charges.create({
  customer: 'cust_test_123456',
  amount: 50000,
  currency: 'THB',
  description: 'Auto-renewal payment'
});

// First charge may require 3D Secure
if (charge.authorize_uri) {
  console.log('3DS required:', charge.authorize_uri);
  // Redirect user for authentication
}

// Subsequent charges typically don't require 3DS
console.log('Charge successful:', charge.status === 'successful');

การเรียกเก็บเงินแบบสำรอง

async function chargeWithFallback(customerId, amount, currency) {
  const customer = await omise.customers.retrieve(customerId);
  const cards = customer.cards.data;

  // Try primary card first
  try {
    return await omise.charges.create({
      customer: customerId,
      card: customer.default_card,
      amount,
      currency,
      description: 'Payment attempt - primary card'
    });
  } catch (primaryError) {
    console.log('Primary card failed:', primaryError.message);

    // Try backup cards
    for (const card of cards) {
      if (card.id === customer.default_card) continue;

      try {
        return await omise.charges.create({
          customer: customerId,
          card: card.id,
          amount,
          currency,
          description: 'Payment attempt - backup card'
        });
      } catch (backupError) {
        console.log(`Backup card ${card.last_digits} failed`);
      }
    }

    throw new Error('All payment methods failed');
  }
}

การจัดการวงจรชีวิตของบัตร

ติดตามบัตรที่กำลังหมดอายุ

async function getExpiringCards(daysAhead = 30) {
  const customers = await omise.customers.list({ limit: 100 });
  const expiringCards = [];

  const today = new Date();
  const futureDate = new Date();
  futureDate.setDate(today.getDate() + daysAhead);

  for (const customer of customers.data) {
    for (const card of customer.cards.data) {
      const cardExpiry = new Date(
        card.expiration_year,
        card.expiration_month - 1,
        1
      );

      if (cardExpiry <= futureDate && cardExpiry >= today) {
        expiringCards.push({
          customer: customer.id,
          email: customer.email,
          card: card.id,
          lastDigits: card.last_digits,
          brand: card.brand,
          expiryMonth: card.expiration_month,
          expiryYear: card.expiration_year
        });
      }
    }
  }

  return expiringCards;
}

// Send notifications
const expiringCards = await getExpiringCards(30);
expiringCards.forEach(card => {
  console.log(
    `Notify ${card.email}: ${card.brand} •••• ${card.lastDigits} ` +
    `expires ${card.expiryMonth}/${card.expiryYear}`
  );
  // Send email notification
});

อัพเดตบัตรที่หมดอายุ

class CardUpdateService {
  async requestCardUpdate(customerId, cardId) {
    // Generate secure update link
    const updateToken = this.generateUpdateToken(customerId, cardId);
    const updateUrl = `https://yourapp.com/update-card?token=${updateToken}`;

    // Send email to customer
    await this.sendUpdateEmail(customerId, updateUrl);

    return updateUrl;
  }

  async processCardUpdate(customerId, newCardToken) {
    // Get old card details
    const customer = await omise.customers.retrieve(customerId);
    const oldCard = customer.cards.data[0];

    // Add new card
    await omise.customers.update(customerId, {
      card: newCardToken
    });

    // Get updated customer with new card
    const updatedCustomer = await omise.customers.retrieve(customerId);
    const newCard = updatedCustomer.cards.data[0];

    // Set as default
    await omise.customers.update(customerId, {
      default_card: newCard.id
    });

    // Remove old card
    await omise.customers.destroyCard(customerId, oldCard.id);

    return newCard;
  }
}

การจัดการการชำระเงินที่ล้มเหลว

async function handleFailedPayment(charge, customerId) {
  const failureCode = charge.failure_code;
  const failureMessage = charge.failure_message;

  console.log(`Payment failed: ${failureCode} - ${failureMessage}`);

  // Handle specific failure types
  switch (failureCode) {
    case 'insufficient_funds':
      // Retry in a few days
      await this.scheduleRetry(customerId, charge.amount, 3);
      await this.notifyCustomer(customerId, 'insufficient_funds');
      break;

    case 'expired_card':
    case 'invalid_card':
      // Request card update
      await this.requestCardUpdate(customerId);
      await this.notifyCustomer(customerId, 'card_update_required');
      break;

    case 'stolen_or_lost_card':
      // Immediately require new card
      await this.suspendSubscription(customerId);
      await this.notifyCustomer(customerId, 'security_issue');
      break;

    default:
      // Try backup card if available
      const customer = await omise.customers.retrieve(customerId);
      if (customer.cards.total > 1) {
        await this.tryBackupCard(customerId, charge.amount);
      }
  }
}

การจัดการบัตรขั้นสูง

การรองรับหลายบัตร

class MultiCardManager {
  async addCard(customerId, cardToken, metadata = {}) {
    const customer = await omise.customers.retrieve(customerId);

    // Check if card already exists (by fingerprint)
    const existingCard = await this.findDuplicateCard(
      customer,
      cardToken
    );

    if (existingCard) {
      return { duplicate: true, card: existingCard };
    }

    // Add new card
    await omise.customers.update(customerId, {
      card: cardToken
    });

    const updatedCustomer = await omise.customers.retrieve(customerId);
    const newCard = updatedCustomer.cards.data[0];

    // Store card metadata in your database
    await this.saveCardMetadata(customerId, newCard.id, metadata);

    return { duplicate: false, card: newCard };
  }

  async findDuplicateCard(customer, cardToken) {
    // Get card fingerprint from token
    const token = await omise.tokens.retrieve(cardToken);
    const fingerprint = token.card.fingerprint;

    // Check existing cards
    return customer.cards.data.find(
      card => card.fingerprint === fingerprint
    );
  }

  async organizeCards(customerId) {
    const customer = await omise.customers.retrieve(customerId);
    const cards = customer.cards.data;

    // Separate by validity
    const valid = [];
    const expiring = [];
    const expired = [];

    const today = new Date();
    const in30Days = new Date();
    in30Days.setDate(today.getDate() + 30);

    cards.forEach(card => {
      const expiry = new Date(
        card.expiration_year,
        card.expiration_month - 1,
        1
      );

      if (expiry < today) {
        expired.push(card);
      } else if (expiry < in30Days) {
        expiring.push(card);
      } else {
        valid.push(card);
      }
    });

    return { valid, expiring, expired };
  }
}

กฎการตรวจสอบบัตร

class CardValidator {
  async validateCard(cardToken) {
    const token = await omise.tokens.retrieve(cardToken);
    const card = token.card;

    // Check expiry
    const expiry = new Date(
      card.expiration_year,
      card.expiration_month - 1,
      1
    );

    if (expiry <= new Date()) {
      return { valid: false, reason: 'Card has expired' };
    }

    // Check security code
    if (!card.security_code_check) {
      return { valid: false, reason: 'Security code check failed' };
    }

    // Check brand
    const allowedBrands = ['Visa', 'MasterCard', 'JCB'];
    if (!allowedBrands.includes(card.brand)) {
      return { valid: false, reason: 'Card brand not supported' };
    }

    return { valid: true };
  }

  async testCard(customerId, cardToken) {
    // Create small test charge
    try {
      const charge = await omise.charges.create({
        customer: customerId,
        card: cardToken,
        amount: 100, // 1.00 THB
        currency: 'THB',
        description: 'Card verification charge'
      });

      // Refund immediately
      if (charge.status === 'successful') {
        await omise.refunds.create(charge.id, {
          amount: charge.amount
        });
      }

      return { valid: true };
    } catch (error) {
      return { valid: false, reason: error.message };
    }
  }
}

ตรรมชาติการลองใหม่อย่างฉลาด

class PaymentRetryService {
  async retryFailedPayment(customerId, amount, currency, attempt = 1) {
    const maxAttempts = 3;
    const backoffDays = [1, 3, 7]; // Retry after 1, 3, and 7 days

    if (attempt > maxAttempts) {
      await this.handleMaxRetriesReached(customerId);
      return null;
    }

    try {
      const charge = await omise.charges.create({
        customer: customerId,
        amount,
        currency,
        description: `Retry attempt ${attempt} of ${maxAttempts}`
      });

      if (charge.status === 'successful') {
        await this.notifyRetrySuccess(customerId, attempt);
        return charge;
      }

    } catch (error) {
      console.log(`Attempt ${attempt} failed:`, error.message);

      // Schedule next retry
      if (attempt < maxAttempts) {
        const nextRetryDays = backoffDays[attempt];
        await this.scheduleRetry(
          customerId,
          amount,
          currency,
          nextRetryDays,
          attempt + 1
        );
      }
    }

    return null;
  }

  async scheduleRetry(customerId, amount, currency, days, attempt) {
    const retryDate = new Date();
    retryDate.setDate(retryDate.getDate() + days);

    // Store retry info in your database
    await this.saveRetrySchedule({
      customerId,
      amount,
      currency,
      retryDate,
      attempt
    });

    // Notify customer
    await this.notifyRetryScheduled(customerId, retryDate, attempt);
  }
}

กรณีการใช้งานทั่วไป

การเรียกเก็บเงินสมาชิกซื้อ

class SubscriptionBilling {
  async processMonthlyBilling() {
    const subscriptions = await this.getActiveSubscriptions();

    for (const sub of subscriptions) {
      try {
        const charge = await omise.charges.create({
          customer: sub.customerId,
          amount: sub.amount,
          currency: 'THB',
          description: `${sub.planName} - ${this.getCurrentBillingPeriod()}`,
          metadata: {
            subscription_id: sub.id,
            billing_period: this.getCurrentBillingPeriod()
          }
        });

        if (charge.status === 'successful') {
          await this.recordSuccessfulPayment(sub.id, charge.id);
          await this.notifyCustomer(sub.customerId, 'payment_success');
        }

      } catch (error) {
        await this.handleFailedPayment(sub, error);
      }
    }
  }

  getCurrentBillingPeriod() {
    const now = new Date();
    return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`;
  }
}

การเรียกเก็บเงินตามการใช้งาน

class UsageBasedBilling {
  async chargeForUsage(customerId, usageData) {
    // Calculate amount based on usage
    const amount = this.calculateAmount(usageData);

    if (amount === 0) {
      console.log('No usage to charge');
      return null;
    }

    const charge = await omise.charges.create({
      customer: customerId,
      amount,
      currency: 'THB',
      description: `Usage billing: ${usageData.units} units`,
      metadata: {
        usage_period: usageData.period,
        units_used: usageData.units,
        rate: usageData.rate
      }
    });

    return charge;
  }

  calculateAmount(usageData) {
    const { units, rate, includedUnits } = usageData;
    const billableUnits = Math.max(0, units - includedUnits);
    return billableUnits * rate;
  }
}

การจัดการ Wallet

class WalletService {
  async topUpWallet(customerId, amount) {
    // Charge saved card
    const charge = await omise.charges.create({
      customer: customerId,
      amount,
      currency: 'THB',
      description: 'Wallet top-up'
    });

    if (charge.status === 'successful') {
      // Add to wallet balance in your database
      await this.addToWalletBalance(customerId, amount);
    }

    return charge;
  }

  async autoTopUp(customerId) {
    const balance = await this.getWalletBalance(customerId);
    const threshold = 10000; // 100.00 THB
    const topUpAmount = 50000; // 500.00 THB

    if (balance < threshold) {
      return await this.topUpWallet(customerId, topUpAmount);
    }

    return null;
  }
}

แนวทางที่ดีที่สุด

ความปลอดภัย

// 1. Never store raw card data
// ✅ Good - Use tokens
const customer = await omise.customers.create({
  email: 'user@example.com',
  card: tokenFromClient
});

// ❌ Bad - Don't store card numbers
// NEVER DO THIS
const user = {
  cardNumber: '4242424242424242',
  cvv: '123'
};

// 2. Validate before saving
async function saveCardSecurely(customerId, cardToken) {
  const validation = await validateCard(cardToken);

  if (!validation.valid) {
    throw new Error(`Invalid card: ${validation.reason}`);
  }

  return await omise.customers.update(customerId, {
    card: cardToken
  });
}

// 3. Monitor for suspicious activity
async function detectFraud(customerId, charge) {
  const recentCharges = await this.getRecentCharges(customerId);

  // Multiple failed attempts
  const failedAttempts = recentCharges.filter(
    c => c.status === 'failed'
  ).length;

  if (failedAttempts >= 3) {
    await this.flagForReview(customerId);
    throw new Error('Multiple failed payment attempts detected');
  }
}

ประสบการณ์ผู้ใช้

// 1. Show clear card information
function displaySavedCard(card) {
  return {
    display: `${card.brand} •••• ${card.last_digits}`,
    expiry: `${card.expiration_month}/${card.expiration_year}`,
    isDefault: card.id === customer.default_card,
    isExpiring: isCardExpiring(card),
    icon: getCardBrandIcon(card.brand)
  };
}

// 2. Proactive expiry notifications
async function sendExpiryReminders() {
  const expiringIn30Days = await getExpiringCards(30);
  const expiringIn7Days = await getExpiringCards(7);

  // First reminder - 30 days
  for (const card of expiringIn30Days) {
    await sendEmail(card.email, 'card-expiring-30-days', card);
  }

  // Final reminder - 7 days
  for (const card of expiringIn7Days) {
    await sendEmail(card.email, 'card-expiring-7-days', card);
  }
}

// 3. Graceful failure handling
async function chargeWithGracefulFailure(customerId, amount) {
  try {
    return await omise.charges.create({
      customer: customerId,
      amount,
      currency: 'THB'
    });
  } catch (error) {
    // User-friendly error messages
    const userMessage = this.getUserFriendlyMessage(error);

    // Log for debugging
    console.error('Charge failed:', error);

    // Notify customer
    await this.notifyCustomer(customerId, userMessage);

    throw new Error(userMessage);
  }
}

ประสิทธิภาพ

// 1. Cache customer data
class CustomerCache {
  constructor() {
    this.cache = new Map();
    this.ttl = 5 * 60 * 1000; // 5 minutes
  }

  async getCustomer(customerId) {
    const cached = this.cache.get(customerId);

    if (cached && Date.now() - cached.timestamp < this.ttl) {
      return cached.data;
    }

    const customer = await omise.customers.retrieve(customerId);
    this.cache.set(customerId, {
      data: customer,
      timestamp: Date.now()
    });

    return customer;
  }
}

// 2. Batch operations
async function batchChargeCustomers(charges) {
  const results = await Promise.allSettled(
    charges.map(({ customerId, amount }) =>
      omise.charges.create({
        customer: customerId,
        amount,
        currency: 'THB'
      })
    )
  );

  const successful = results.filter(r => r.status === 'fulfilled');
  const failed = results.filter(r => r.status === 'rejected');

  return { successful, failed };
}

การแก้ไขปัญหา

บัตรมีอยู่แล้ว

// Check for duplicate cards before adding
async function addCardSafely(customerId, cardToken) {
  const token = await omise.tokens.retrieve(cardToken);
  const customer = await omise.customers.retrieve(customerId);

  // Check if card with same fingerprint exists
  const duplicate = customer.cards.data.find(
    card => card.fingerprint === token.card.fingerprint
  );

  if (duplicate) {
    return {
      added: false,
      message: 'This card is already saved',
      existingCard: duplicate
    };
  }

  await omise.customers.update(customerId, { card: cardToken });
  return { added: true };
}

การเรียกเก็บเงินล้มเหลวด้วยบัตรที่บันทึกไว้

async function diagnoseChargeFailure(customerId, error) {
  console.log('Diagnosing charge failure...');

  // Check customer exists
  let customer;
  try {
    customer = await omise.customers.retrieve(customerId);
  } catch (e) {
    return 'Customer not found';
  }

  // Check has payment method
  if (!customer.default_card) {
    return 'No default payment method';
  }

  // Check card validity
  const card = customer.cards.data.find(
    c => c.id === customer.default_card
  );

  const expiry = new Date(
    card.expiration_year,
    card.expiration_month - 1,
    1
  );

  if (expiry < new Date()) {
    return 'Card has expired';
  }

  // Check error code
  if (error.code === 'insufficient_funds') {
    return 'Insufficient funds on card';
  }

  return 'Unknown error - contact support';
}

ไม่สามารถนำบัตรออก

async function removeCardSafely(customerId, cardId) {
  const customer = await omise.customers.retrieve(customerId);

  // Prevent removing only card
  if (customer.cards.total === 1) {
    throw new Error('Cannot remove the only payment method');
  }

  // If removing default, set new default first
  if (customer.default_card === cardId) {
    const otherCard = customer.cards.data.find(c => c.id !== cardId);

    await omise.customers.update(customerId, {
      default_card: otherCard.id
    });
  }

  // Now safe to remove
  await omise.customers.destroyCard(customerId, cardId);
}

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

คำถามทั่วไป

Q: บัตรที่บันทึกไว้ยังคงมีอายุเท่านาน?

A: บัตรที่บันทึกไว้ยังคงใช้ได้จนกว่าจะหมดอายุหรือถูกลบด้วยตนเอง ติดตามวันที่หมดอายุและขอการปรับปรุงอย่างเหมาะสม

Q: ลูกค้าสามารถบันทึกบัตรจากประเทศต่างๆ ได้หรือไม่?

A: ได้ ลูกค้าสามารถบันทึกบัตรจากประเทศใดก็ได้ โดยขึ้นอยู่กับประเทศและสกุลเงินที่บัญชีของคุณรองรับ

Q: บัตรที่บันทึกไว้ต้องใช้ CVV ในการเรียกเก็บเงินหรือไม่?

A: ไม่ เมื่อบัตรถูกบันทึกแล้ว (ตรวจสอบ CVV แล้ว) การเรียกเก็บเงินครั้งต่อไปจะไม่ต้องใช้ CVV

Q: ฉันสามารถย้ายบัตรที่บันทึกไว้ระหว่างระบบได้หรือไม่?

A: ไม่ สำหรับเหตุผลด้านความปลอดภัย ไม่สามารถส่งออก card tokens ได้ ลูกค้าต้องป้อนข้อมูลการชำระเงินใหม่เมื่อโยกย้ายแพลตฟอร์ม

Q: จะเกิดอะไรขึ้นหากบัตรที่บันทึกไว้หมดอายุ?

A: การเรียกเก็บเงินจะล้มเหลว ติดตามวันที่หมดอายุอย่างเหมาะสมและขอข้อมูลบัตรที่อัพเดตจากลูกค้า

Q: ลูกค้าสามารถบันทึกบัตรได้กี่ใบ?

A: ไม่มีขีดจำกัดที่เข้มงวด แต่สำหรับ UX ที่ดีที่สุด เราแนะนำให้อนุญาตบัตรที่ใช้งานอยู่ 3-5 ใบต่อลูกค้า

คำถามเกี่ยวกับความปลอดภัย

Q: บัตรที่บันทึกไว้เป็นไปตามข้อกำหนด PCI หรือไม่?

A: ใช่ Omise จัดการการเก็บบัตรทั้งหมดในโครงสร้างพื้นฐาน PCI DSS ระดับ 1 ที่ปฏิบัติตามข้อกำหนด คุณไม่ได้เก็บข้อมูลบัตรใดๆ

Q: บัตรที่บันทึกไว้สามารถใช้งานเป็นการฉ้อโกงได้หรือไม่?

A: Omise ใช้การตรวจจับการฉ้อโกงและ 3D Secure เมื่อเหมาะสม ติดตามรูปแบบที่น่าสงสัยในแอปพลิเคชันของคุณ

Q: ฉันควรใช้การตรวจสอบเพิ่มเติมสำหรับการเรียกเก็บเงินบัตรที่บันทึกไว้หรือไม่?

A: สำหรับการทำรายการมูลค่าสูงหรือกิจกรรมที่น่าสงสัย ให้พิจารณาการรับรองความถูกต้องเพิ่มเติม (SMS OTP, ยืนยันอีเมล ฯลฯ)

Q: ฉันจะจัดการบัตรที่ถูกบุกรุกได้อย่างไร?

A: นำบัตรที่ถูกบุกรุกออกทันทีและแจ้งให้ลูกค้าทราบเพื่อเพิ่มวิธีการชำระเงินใหม่

คำถามทางเทคนิค

Q: ฉันสามารถเรียกเก็บเงินจากบัตรที่บันทึกไว้ในสกุลเงินอื่นได้หรือไม่?

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

Q: อะไรคือความแตกต่างระหว่างพารามิเตอร์การ์ดและโทเค็น?

A: ใช้ card (token ID) เมื่อบันทึกบัตรใหม่ ใช้ card (card ID) เมื่อเรียกเก็บเงินจากบัตรที่บันทึกไว้เฉพาะ

Q: ฉันสามารถอัพเดตรายละเอียดบัตรที่บันทึกไว้ได้หรือไม่?

A: ไม่ คุณไม่สามารถอัพเดตรายละเอียดบัตร นำบัตรเก่าออกและเพิ่มบัตรใหม่พร้อมข้อมูลที่อัพเดต

Q: ฉันจะจัดการ 3D Secure กับบัตรที่บันทึกไว้ได้อย่างไร?

A: การเรียกเก็บเงินครั้งแรกอาจต้องใช้ 3D Secure การเรียกเก็บเงินครั้งต่อไปมักจะไม่ต้อง แต่ธนาคารอาจขอการทำรายการที่มีความเสี่ยงสูง

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

• การจัดการลูกค้า
• ตารางเวลาแบบวนซ้ำ
• API อ้างอิง Tokens
• API อ้างอิง Cards
• API อ้างอิง Charges
• แนวทางปฏิบัติที่ดีที่สุดด้านความปลอดภัย
• Webhooks

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

• ตารางเวลาแบบวนซ้ำ
• Webhooks Integration
• การจัดการสมาชิกซื้อ
• การจัดการการชำระเงินที่ล้มเหลว
• การทดสอบบัตรที่บันทึกไว้