API 2Checkout: Panduan Integrasi Lengkap untuk Pemrosesan Pembayaran (2026)

Intinya

API 2Checkout (sekarang Verifone) memungkinkan pengembang untuk memproses pembayaran, mengelola langganan, dan menangani transaksi e-commerce secara terprogram. Ini mendukung titik akhir RESTful untuk pesanan, pelanggan, produk, dan webhook dengan otentikasi berbasis JSON menggunakan kunci API. Panduan ini mencakup segala hal mulai dari penyiapan awal hingga penanganan webhook lanjutan.

Pendahuluan

Pemrosesan pembayaran adalah tulang punggung setiap bisnis online. Jika salah, Anda kehilangan pendapatan. Jika benar, Anda membuka pasar global. API 2Checkout (baru-baru ini di-rebranding menjadi Verifone) menangani pembayaran untuk lebih dari 45.000 merchant di seluruh dunia, memproses miliaran transaksi setiap tahunnya.

Inilah kenyataannya: 67% pembeli meninggalkan keranjang belanja karena gesekan pembayaran. Integrasi API pembayaran yang solid secara langsung memengaruhi pendapatan Anda.

Panduan ini membahas proses integrasi API 2Checkout secara lengkap. Anda akan mempelajari otentikasi, pemrosesan pembayaran, manajemen langganan, penanganan webhook, dan pemecahan masalah kesalahan. Pada akhirnya, Anda akan memiliki integrasi pembayaran yang siap produksi.

Apa Itu API 2Checkout?

2Checkout (sekarang beroperasi sebagai Verifone Digital Commerce) menyediakan API RESTful untuk pemrosesan pembayaran dan manajemen langganan. API ini menangani:

• Pembayaran sekali bayar dan berulang
• Manajemen pelanggan dan produk
• Pelacakan siklus hidup pesanan
• Penanganan pengembalian dana dan sengketa
• Otomatisasi pajak dan kepatuhan
• Dukungan multi-mata uang (100+ mata uang)

Fitur Utama

Gambaran Umum Arsitektur API

2Checkout menggunakan struktur API REST yang terversi:

https://api.2checkout.com/1/
https://api.2checkout.com/2/

Versi 2 adalah versi yang direkomendasikan saat ini dengan manajemen langganan dan penanganan webhook yang ditingkatkan.

Memulai: Penyiapan Otentikasi

Langkah 1: Buat Akun 2Checkout Anda

Sebelum mengakses API, Anda memerlukan akun merchant:

1. Kunjungi halaman pendaftaran 2Checkout (Verifone)
2. Selesaikan verifikasi bisnis (membutuhkan dokumen bisnis)
3. Tunggu persetujuan (biasanya 24-48 jam)
4. Akses Panel Kontrol Anda untuk mengambil kredensial API

Langkah 2: Ambil Kunci API

Navigasikan ke Integrations > API Keys di Panel Kontrol Anda:

• Kunci API Pribadi: Digunakan untuk otentikasi sisi server (jaga kerahasiaan ini)
• Kunci API Publik: Digunakan untuk tokenisasi sisi klien (aman untuk diekspos)
• Rahasia Webhook: Digunakan untuk memverifikasi tanda tangan webhook

Catatan keamanan: Jangan pernah menyimpan kunci API ke kontrol versi. Gunakan variabel lingkungan:

# .env file
TWOCHECKOUT_PRIVATE_KEY="kunci_pribadi_anda_di_sini"
TWOCHECKOUT_PUBLIC_KEY="kunci_publik_anda_di_sini"
TWOCHECKOUT_WEBHOOK_SECRET="rahasia_webhook_anda_di_sini"

Langkah 3: Sandbox vs Produksi

2Checkout menyediakan lingkungan terpisah:

Gunakan kredensial sandbox selama pengembangan. Beralihlah ke kunci produksi hanya saat siap untuk memproses pembayaran nyata.

Langkah 4: Metode Otentikasi

2Checkout mendukung dua pendekatan otentikasi:

Metode 1: Otentikasi Kunci API (Disarankan)

Sertakan kunci pribadi Anda di header permintaan:

const response = await fetch('https://api.2checkout.com/1/orders', {
  method: 'GET',
  headers: {
    'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
    'Content-Type': 'application/json',
    'Accept': 'application/json'
  }
});

Metode 2: Otentikasi Tanda Tangan HMAC

Untuk keamanan yang ditingkatkan, tanda tangani permintaan dengan HMAC-SHA256:

const crypto = require('crypto');

function generateSignature(payload, privateKey) {
  const hash = crypto
    .createHmac('sha256', privateKey)
    .update(JSON.stringify(payload))
    .digest('hex');
  return hash;
}

// Usage
const payload = { order_id: '12345', amount: 99.99 };
const signature = generateSignature(payload, privateKey);

const response = await fetch('https://api.2checkout.com/1/orders', {
  method: 'POST',
  headers: {
    'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
    'X-Signature': signature,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(payload)
});

Memproses Pembayaran: Titik Akhir Utama

Membuat Pesanan Sekali Bayar

Proses pembayaran tunggal dengan titik akhir /orders:

const createOrder = async (customerData, productData) => {
  const payload = {
    currency: 'USD',
    customer: {
      email: customerData.email,
      first_name: customerData.firstName,
      last_name: customerData.lastName,
      phone: customerData.phone,
      billing_address: {
        address1: customerData.address,
        city: customerData.city,
        state: customerData.state,
        zip: customerData.zip,
        country: customerData.country
      }
    },
    items: [
      {
        name: productData.name,
        quantity: productData.quantity,
        price: productData.price,
        product_code: productData.sku
      }
    ],
    payment_method: {
      type: 'card',
      card_token: customerData.cardToken // Dari tokenisasi sisi klien
    }
  };

  const response = await fetch('https://api.2checkout.com/1/orders', {
    method: 'POST',
    headers: {
      'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(payload)
  });

  return await response.json();
};

Respons yang Diharapkan

{
  "order_id": "ORD-2026-001234",
  "status": "approved",
  "amount": 99.99,
  "currency": "USD",
  "customer_id": "CUST-789456",
  "transaction_id": "TXN-9876543210",
  "created_at": "2026-03-20T10:30:00Z"
}

Menangani Kesalahan Pembayaran

Selalu terapkan penanganan kesalahan yang tepat:

try {
  const result = await createOrder(customer, product);

  if (result.error) {
    // Tangani kode kesalahan tertentu
    switch (result.error.code) {
      case 'CARD_DECLINED':
        // Minta pelanggan untuk menggunakan kartu yang berbeda
        break;
      case 'INSUFFICIENT_FUNDS':
        // Tampilkan pesan yang sesuai
        break;
      case 'INVALID_CVV':
        // Minta CVV dimasukkan kembali
        break;
      default:
        // Catat dan tampilkan kesalahan umum
        console.error('Pembayaran gagal:', result.error);
    }
  }
} catch (error) {
  // Kesalahan jaringan atau server
  console.error('Permintaan API gagal:', error);
}

Kode Kesalahan Umum

Manajemen Pelanggan

Mengelola data pelanggan sangat penting untuk bisnis langganan dan pembelian berulang. 2Checkout menyediakan API pelanggan yang lengkap.

Membuat Pelanggan

const createCustomer = async (customerData) => {
  const payload = {
    email: customerData.email,
    first_name: customerData.firstName,
    last_name: customerData.lastName,
    phone: customerData.phone,
    company: customerData.company,
    billing_address: {
      address1: customerData.address,
      address2: customerData.address2 || '',
      city: customerData.city,
      state: customerData.state,
      zip: customerData.zip,
      country: customerData.country
    },
    shipping_address: customerData.shippingAddress || null,
    tax_exempt: false,
    language: 'en'
  };

  const response = await fetch('https://api.2checkout.com/1/customers', {
    method: 'POST',
    headers: {
      'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(payload)
  });

  return await response.json();
};

Respons Pelanggan

{
  "customer_id": "CUST-2026-123456",
  "email": "john.doe@example.com",
  "first_name": "John",
  "last_name": "Doe",
  "created_at": "2026-03-20T10:00:00Z",
  "updated_at": "2026-03-20T10:00:00Z",
  "payment_methods": [],
  "subscriptions": [],
  "order_history": []
}

Mengambil Detail Pelanggan

const getCustomer = async (customerId) => {
  const response = await fetch(
    `https://api.2checkout.com/1/customers/${customerId}`,
    {
      method: 'GET',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
        'Content-Type': 'application/json'
      }
    }
  );

  return await response.json();
};

Memperbarui Informasi Pelanggan

const updateCustomer = async (customerId, updates) => {
  const response = await fetch(
    `https://api.2checkout.com/1/customers/${customerId}`,
    {
      method: 'PUT',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(updates)
    }
  );

  return await response.json();
};

Menghapus Pelanggan

const deleteCustomer = async (customerId) => {
  const response = await fetch(
    `https://api.2checkout.com/1/customers/${customerId}`,
    {
      method: 'DELETE',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY
      }
    }
  );

  return response.status === 204; // Tidak ada konten saat berhasil
};

Catatan: Menghapus pelanggan dengan langganan aktif atau saldo terutang akan gagal. Batalkan langganan terlebih dahulu.

Pola Integrasi Lanjutan

Idempotensi untuk Percobaan Ulang yang Aman

API pembayaran harus mendukung permintaan idempoten untuk mencegah tagihan ganda:

const createIdempotentOrder = async (payload, idempotencyKey) => {
  const response = await fetch('https://api.2checkout.com/1/orders', {
    method: 'POST',
    headers: {
      'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
      'Content-Type': 'application/json',
      'X-Idempotency-Key': idempotencyKey // Unik per pesanan
    },
    body: JSON.stringify(payload)
  });

  return await response.json();
};

// Hasilkan kunci unik per pesanan (simpan di database Anda)
const idempotencyKey = `order_${userId}_${Date.now()}`;

Jika permintaan habis waktu tetapi 2Checkout memprosesnya, mencoba lagi dengan kunci yang sama akan mengembalikan hasil asli alih-alih menagih dua kali.

Menangani 3D Secure 2.0 (Kepatuhan UE)

Untuk pelanggan Eropa, otentikasi 3D Secure 2.0 wajib di bawah PSD2:

const createOrderWith3DS = async (payload) => {
  const response = await fetch('https://api.2checkout.com/1/orders', {
    method: 'POST',
    headers: {
      'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      ...payload,
      three_ds: {
        enabled: true,
        challenge_required: 'preferred', // atau 'mandatory' untuk UE
        notification_url: 'https://situs-anda.com/3ds-callback'
      }
    })
  });

  const result = await response.json();

  // Tangani pengalihan 3DS
  if (result.three_ds_redirect_url) {
    // Alihkan pelanggan ke bank mereka untuk otentikasi
    res.redirect(result.three_ds_redirect_url);
  }

  return result;
};

Penetapan Harga Multi-Mata Uang

Tampilkan harga dalam mata uang lokal sambil melakukan penyelesaian dalam mata uang dasar Anda:

const getLocalizedPrice = async (basePrice, targetCurrency) => {
  const response = await fetch(
    `https://api.2checkout.com/1/rates?from=USD&to=${targetCurrency}`,
    {
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY
      }
    }
  );

  const rates = await response.json();
  return basePrice * rates.rate;
};

// Penggunaan
const eurPrice = await getLocalizedPrice(99.99, 'EUR');
console.log(`Harga: EUR ${eurPrice.toFixed(2)}`);

Prorata untuk Peningkatan Langganan

Ketika pelanggan meningkatkan paket di tengah siklus, hitung tagihan prorata:

const upgradeSubscription = async (subscriptionId, newPlanId) => {
  const response = await fetch(
    `https://api.2checkout.com/1/subscriptions/${subscriptionId}/upgrade`,
    {
      method: 'POST',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        plan_id: newPlanId,
        proration: 'immediate', // Tagih perbedaan sekarang
        invoice_proration: true  // Tampilkan item baris pada faktur
      })
    }
  );

  return await response.json();
};

Pemecahan Masalah Umum

Masalah: Webhook Tidak Tiba

Gejala: Pesanan diproses tetapi sistem Anda tidak diperbarui.

Diagnosis:

// Periksa log pengiriman webhook di dashboard 2Checkout
// Cari upaya pengiriman yang gagal atau respons non-200

Solusi:

1. Verifikasi titik akhir mengembalikan 200 OK dalam 5 detik
2. Periksa validitas sertifikat SSL (harus HTTPS)
3. Tambahkan rentang IP 2Checkout ke daftar putih di firewall Anda
4. Tinjau logika verifikasi tanda tangan webhook
5. Uji dengan simulator webhook sebelum produksi

Masalah: Pembayaran Uji Gagal di Sandbox

Gejala: Semua kartu uji ditolak di lingkungan sandbox.

Solusi:

1. Konfirmasikan menggunakan kunci API sandbox (bukan produksi)
2. Verifikasi URL dasar sandbox: https://sandbox.2checkout.com/api/
3. Gunakan nomor kartu uji yang benar (lihat bagian Pengujian)
4. Periksa status akun sandbox (mungkin kedaluwarsa setelah tidak aktif)

Masalah: Perpanjangan Langganan Gagal Diam-diam

Gejala: Langganan ditampilkan aktif tetapi perpanjangan tidak diproses.

Diagnosis:

// Kueri riwayat pembayaran langganan
const history = await fetch(
  `https://api.2checkout.com/1/subscriptions/${subId}/payments`,
  { headers: { 'X-Api-Key': privateKey } }
);

Solusi:

1. Periksa kedaluwarsa metode pembayaran pelanggan
2. Tinjau pengaturan dunning di Panel Kontrol
3. Verifikasi pengiriman webhook untuk subscription.payment_failed
4. Konfirmasikan flag auto_renew diaktifkan

Masalah: Perbedaan Konversi Mata Uang

Gejala: Jumlah yang ditagihkan berbeda dari konversi yang diharapkan.

Penyebab: 2Checkout menggunakan nilai tukar harian, yang berfluktuasi.

Solusi:

• Tampilkan konversi "perkiraan" dengan penafian
• Kunci nilai tukar saat pembuatan keranjang dengan kedaluwarsa 15 menit
• Simpan transaksi dalam mata uang lokal pelanggan

Masalah: Kegagalan AVS (Verifikasi Alamat)

Gejala: Kartu yang sah ditolak karena ketidakcocokan alamat.

Solusi:

1. Gunakan pelengkapan otomatis alamat (Google Places, Lob)
2. Jadikan kode pos/ZIP wajib saat checkout
3. Terapkan AVS lunak (peringatan alih-alih penolakan)
4. Izinkan pelanggan untuk memperbarui alamat penagihan

Manajemen Langganan

2Checkout unggul dalam penagihan berulang. Berikut cara mengelola langganan:

Membuat Langganan

const createSubscription = async (customerId, planId) => {
  const payload = {
    customer_id: customerId,
    plan_id: planId,
    start_date: new Date().toISOString(),
    billing_cycle: 'monthly', // atau 'annual', 'weekly'
    payment_method: {
      type: 'card',
      card_token: 'tok_card_tokenized'
    },
    options: {
      trial_days: 14, // Uji coba gratis opsional
      auto_renew: true
    }
  };

  const response = await fetch('https://api.2checkout.com/1/subscriptions', {
    method: 'POST',
    headers: {
      'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(payload)
  });

  return await response.json();
};

Respons Langganan

{
  "subscription_id": "SUB-2026-567890",
  "status": "active",
  "plan_id": "PLAN-PREMIUM-MONTHLY",
  "customer_id": "CUST-789456",
  "current_period_start": "2026-03-20T00:00:00Z",
  "current_period_end": "2026-04-20T00:00:00Z",
  "trial_end": "2026-04-03T00:00:00Z",
  "amount": 29.99,
  "currency": "USD"
}

Memperbarui Langganan

Ubah paket, perbarui metode pembayaran, atau modifikasi kuantitas:

const updateSubscription = async (subscriptionId, updates) => {
  const payload = {
    ...updates
    // Contoh:
    // plan_id: 'PLAN-ENTERPRISE-MONTHLY',
    // quantity: 5,
    // payment_method: { card_token: 'new_token' }
  };

  const response = await fetch(
    `https://api.2checkout.com/1/subscriptions/${subscriptionId}`,
    {
      method: 'PUT',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(payload)
    }
  );

  return await response.json();
};

Membatalkan Langganan

const cancelSubscription = async (subscriptionId, reason = '') => {
  const payload = {
    cancel_at_period_end: false, // true = batalkan setelah periode saat ini, false = segera
    reason: reason
  };

  const response = await fetch(
    `https://api.2checkout.com/1/subscriptions/${subscriptionId}/cancel`,
    {
      method: 'POST',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(payload)
    }
  );

  return await response.json();
};

Integrasi Webhook: Penanganan Peristiwa Waktu Nyata

Webhook memberi tahu sistem Anda tentang peristiwa pembayaran tanpa polling. Ini sangat penting untuk perpanjangan langganan, pembayaran yang gagal, dan pengembalian dana.

Langkah 1: Konfigurasi Titik Akhir Webhook

Di Panel Kontrol 2Checkout Anda:

1. Navigasikan ke Integrations > Webhooks
2. Tambahkan URL titik akhir Anda (harus menggunakan HTTPS)
3. Pilih peristiwa yang akan dilanggan
4. Simpan dan catat Rahasia Webhook Anda

Langkah 2: Buat Handler Webhook

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

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

  // Verifikasi tanda tangan webhook
  const isValid = verifyWebhookSignature(payload, signature, process.env.TWOCHECKOUT_WEBHOOK_SECRET);

  if (!isValid) {
    console.error('Tanda tangan webhook tidak valid');
    return res.status(401).send('Tidak Sah');
  }

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

  // Rutekan ke handler yang sesuai
  switch (event.type) {
    case 'order.created':
      await handleOrderCreated(event.data);
      break;
    case 'order.approved':
      await handleOrderApproved(event.data);
      break;
    case 'order.declined':
      await handleOrderDeclined(event.data);
      break;
    case 'subscription.created':
      await handleSubscriptionCreated(event.data);
      break;
    case 'subscription.renewed':
      await handleSubscriptionRenewed(event.data);
      break;
    case 'subscription.cancelled':
      await handleSubscriptionCancelled(event.data);
      break;
    case 'refund.processed':
      await handleRefundProcessed(event.data);
      break;
    default:
      console.log('Jenis peristiwa yang tidak ditangani:', event.type);
  }

  // Akui penerimaan
  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')
  );
}

Peristiwa Webhook Penting

Praktik Terbaik Webhook

1. Selalu verifikasi tanda tangan - Mencegah webhook palsu
2. Kembalikan 200 OK dengan cepat - 2Checkout mencoba lagi pada respons non-200
3. Proses secara asinkron - Antrekan peristiwa untuk pemrosesan latar belakang
4. Terapkan idempotensi - Tangani pengiriman webhook ganda
5. Catat semuanya - Debug sengketa pembayaran dengan log bertanda waktu

Menguji Integrasi Anda

Menggunakan Lingkungan Sandbox

Sandbox 2Checkout memungkinkan Anda menguji tanpa biaya nyata:

// Gunakan URL dasar sandbox
const BASE_URL = 'https://sandbox.2checkout.com/api/1';

// Nomor kartu uji
const TEST_CARDS = {
  APPROVED: '4111111111111111',
  DECLINED: '4000000000000002',
  INSUFFICIENT_FUNDS: '4000000000009995',
  EXPIRED_CARD: '4000000000000069'
};

// Alamat uji
const TEST_ADDRESS = {
  country: 'US',
  zip: '90210' // Memicu pemeriksaan AVS
};

Menguji Webhook Secara Lokal

Gunakan ngrok untuk mengekspos server lokal Anda:

# Instal ngrok
npm install -g ngrok

# Mulai server Anda di port 3000
node server.js

# Ekspos ke internet
ngrok http 3000

# Salin URL ngrok ke pengaturan webhook 2Checkout

Apidog untuk Pengujian API

Apidog merampingkan pengujian API 2Checkout:

1. Impor Spesifikasi OpenAPI - Muat definisi API 2Checkout
2. Buat Skenario Uji - Bangun koleksi untuk setiap titik akhir
3. Mock Respons - Uji tanpa memanggil API secara langsung
4. Validasi Webhook - Periksa struktur payload
5. Bagikan dengan Tim - Berkolaborasi dalam pengujian integrasi

Buat variabel lingkungan untuk kunci sandbox vs produksi, lalu alihkan konteks dengan satu klik.

Daftar Periksa Penyebaran Produksi

Sebelum tayang langsung:

• [ ] Beralih dari kunci API sandbox ke produksi
• [ ] Perbarui URL dasar ke https://api.2checkout.com/
• [ ] Aktifkan verifikasi tanda tangan webhook
• [ ] Siapkan pemantauan untuk pembayaran yang gagal
• [ ] Konfigurasi logika coba ulang untuk kegagalan sementara
• [ ] Uji alur pengembalian dana dan chargeback
• [ ] Verifikasi kepatuhan PCI DSS (gunakan tokenisasi)
• [ ] Aktifkan 3D Secure 2.0 untuk pelanggan UE
• [ ] Siapkan pencatatan untuk jejak audit
• [ ] Buat runbook untuk masalah pembayaran

Pemantauan dan Peringatan

Lacak metrik ini:

// Contoh: Tingkat keberhasilan pembayaran
const successRate = approvedOrders / totalOrders * 100;

if (successRate < 95) {
  // Beri tahu tim pembayaran
  sendAlert('Tingkat keberhasilan pembayaran turun di bawah 95%');
}

// Lacak kode kesalahan tertentu
const errorBreakdown = errors.reduce((acc, err) => {
  acc[err.code] = (acc[err.code] || 0) + 1;
  return acc;
}, {});

// Beri tahu jika ada lonjakan kesalahan tertentu
if (errorBreakdown['CARD_DECLINED'] > threshold) {
  sendAlert('Terdeteksi lonjakan penolakan kartu');
}

Studi Kasus Dunia Nyata

Integrasi Toko E-commerce

Pengecer fashion mengintegrasikan 2Checkout untuk menangani pembayaran global. Hasil:

• Mendukung 100+ mata uang secara otomatis
• Mengurangi pengabaian keranjang belanja sebesar 23%
• Menangani kepatuhan PPN UE secara otomatis
• Memproses lebih dari $2 juta pada tahun pertama

Implementasi memakan waktu 3 minggu menggunakan halaman checkout yang di-hosting 2Checkout pada awalnya, lalu bermigrasi ke integrasi API langsung untuk UX kustom.

Bisnis Langganan SaaS

SaaS manajemen proyek menggunakan langganan 2Checkout:

• Mengelola 5.000+ langganan aktif
• Menangani prorata untuk peningkatan paket
• Mengotomatisasi dunning untuk perpanjangan yang gagal
• Mengurangi churn sebesar 15% dengan coba ulang cerdas

Fitur utama: Kontrol akses berbasis Webhook. Ketika subscription.renewed tiba, segera perpanjang akses pengguna. Ketika subscription.cancelled, jadwalkan pencabutan akses.

Kesimpulan

API 2Checkout menyediakan semua yang dibutuhkan untuk pemrosesan pembayaran dan manajemen langganan. Poin-poin penting:

• Gunakan lingkungan sandbox untuk semua pengembangan dan pengujian
• Terapkan verifikasi tanda tangan HMAC untuk webhook
• Tangani kesalahan dengan anggun dengan penanganan kode kesalahan tertentu
• Uji alur langganan secara menyeluruh (uji coba, perpanjangan, pembatalan)
• Pantau metrik pembayaran dalam produksi
• Gunakan Apidog untuk merampingkan pengujian API dan kolaborasi tim

Bagian FAQ

Apa itu API 2Checkout?

API 2Checkout (sekarang Verifone) adalah antarmuka RESTful untuk memproses pembayaran, mengelola langganan, menangani pengembalian dana, dan mengotomatisasi transaksi e-commerce. Ini mendukung payload JSON, otentikasi HMAC, dan webhook real-time.

Apakah 2Checkout sama dengan Verifone?

Ya. 2Checkout diakuisisi oleh Verifone pada tahun 2020 dan di-rebranding menjadi Verifone Digital Commerce. Titik akhir API dan fungsionalitas tetap sama, meskipun beberapa dokumentasi merujuk pada Verifone.

Bagaimana cara mendapatkan kunci API 2Checkout saya?

Masuk ke Panel Kontrol 2Checkout Anda, navigasikan ke Integrations > API Keys, dan buat kunci baru. Anda akan menerima kunci pribadi (sisi server) dan kunci publik (tokenisasi sisi klien).

Apakah 2Checkout memiliki lingkungan sandbox?

Ya. Gunakan https://sandbox.2checkout.com/api/ untuk pengujian. Buat akun sandbox terpisah untuk mendapatkan kunci API uji dan memproses transaksi uji tanpa biaya nyata.

Metode pembayaran apa saja yang didukung 2Checkout?

2Checkout mendukung kartu kredit (Visa, Mastercard, Amex, Discover), PayPal, Apple Pay, Google Pay, transfer bank, dan metode pembayaran lokal di 100+ negara.

Bagaimana cara menangani webhook dengan aman?

Selalu verifikasi header X-Webhook-Signature menggunakan HMAC-SHA256 dengan rahasia webhook Anda. Proses peristiwa secara asinkron dan segera kembalikan 200 OK untuk mencegah percobaan ulang.

Apa yang terjadi jika pembayaran langganan gagal?

2Checkout mengirim webhook subscription.payment_failed. Terapkan logika coba ulang (biasanya 3 kali percobaan selama 7 hari) dan kirim webhook subscription.cancelled jika semua percobaan gagal.

Apakah 2Checkout mematuhi PCI DSS?

Ya, 2Checkout bersertifikasi PCI DSS Level 1. Gunakan tokenisasi sisi klien untuk menghindari penanganan data kartu mentah, yang mengurangi cakupan kepatuhan PCI Anda.

Bisakah saya menguji langganan di sandbox?

Ya. Sandbox mendukung pengujian siklus hidup langganan penuh termasuk uji coba, perpanjangan, peningkatan, penurunan, dan pembatalan. Gunakan kartu uji 4111111111111111 untuk pembayaran yang berhasil.

Bagaimana cara menangani pengembalian dana melalui API?

Kirim permintaan POST ke /refunds dengan ID pesanan dan jumlah pengembalian dana. 2Checkout memproses pengembalian dana sebagian atau penuh dan mengirim webhook refund.processed setelah selesai.