Dynamic Pricing Checkout dengan Pay What You Want

Buat tautan checkout fleksibel dengan harga variabel menggunakan satu produk. Aktifkan Pay What You Want agar pelanggan dapat memilih harga mereka atau menetapkan jumlah dinamis secara terprogram.

Dynamic pricing memungkinkan Anda menawarkan harga variabel untuk produk tanpa membuat beberapa entri produk. Dengan mengaktifkan Pay What You Want (PWYW) pada satu produk, Anda dapat menetapkan batas harga minimum dan maksimum, lalu mengirimkan jumlah dinamis saat membuat tautan checkout session.

Pendekatan ini ideal jika Anda memerlukan:

• Harga variabel tanpa mengelola banyak produk
• Harga yang ditentukan pelanggan sehingga pembeli dapat memilih jumlahnya
• Kontrol harga secara terprogram sehingga Anda dapat menetapkan jumlah secara dinamis melalui API
• Model harga fleksibel untuk produk digital, donasi, atau peluncuran eksperimental

Pay What You Want hanya tersedia untuk produk Single Payment (satu kali). Fitur ini tidak dapat digunakan dengan produk subscription.

​

Cara Kerjanya

Dengan Pay What You Want yang diaktifkan, Anda dapat:

1. Menetapkan batas harga: Tentukan harga minimum (wajib) dan harga maksimum secara opsional
2. Mengirimkan jumlah dinamis: Sertakan field amount dalam product cart saat membuat checkout session
3. Membiarkan pelanggan memilih: Jika tidak ada jumlah yang diberikan, pelanggan dapat memasukkan harga mereka sendiri (dalam batas yang Anda tetapkan)

Saat Anda mengirimkan amount dalam product cart, jumlah tersebut digunakan untuk checkout. Jika Anda tidak menyertakan field amount, pelanggan dapat memilih harga mereka sendiri selama checkout (sesuai pengaturan minimum/maksimum Anda).

​

Langkah 1: Membuat Produk dengan Pay What You Want

Pertama, buat produk sekali bayar di dashboard Dodo Payments Anda dan aktifkan harga Pay What You Want.

1. Create a new product

   Buka Products di dashboard Dodo Payments Anda, lalu klik Add Product.

2. Configure product details

   Isi informasi produk yang wajib diisi:

   • Product Name: Nama tampilan untuk produk Anda
   • Product Description: Deskripsi yang jelas tentang apa yang dibeli pelanggan
   • Product Image: Unggah gambar (PNG/JPG/WebP, hingga 3 MB)
   • Tax Category: Pilih kategori pajak yang sesuai
3. Set pricing type

   Pilih Pricing Type sebagai Single Payment (pembayaran satu kali).

4. Enable Pay What You Want

   Di bagian Pricing, aktifkan toggle Pay What You Want.

5. Set minimum price

   Masukkan Minimum Price yang harus dibayar pelanggan. Pengaturan ini wajib diisi dan memastikan Anda mempertahankan batas minimum pendapatan.

   Contoh: Jika minimum Anda adalah $5.00, masukkan 5.00 (atau 500 sen).

6. Set maximum price (optional)

   Secara opsional, tetapkan Maximum Price untuk membatasi jumlah yang dapat dibayar pelanggan.

7. Set suggested price (optional)

   Secara opsional, masukkan Suggested Price yang akan ditampilkan untuk membantu pelanggan. Ini membantu membentuk ekspektasi dan dapat meningkatkan nilai pesanan rata-rata.

8. Save the product

   Klik Add Product untuk menyimpan. Catat ID produk Anda (misalnya, pdt_123abc456def) untuk digunakan dalam checkout session.

Anda dapat menemukan ID produk di dashboard pada Products → View Details, atau dengan menggunakan List Products API.

​

Langkah 2: Membuat Checkout Session dengan Dynamic Pricing

Setelah produk dikonfigurasi dengan Pay What You Want, Anda dapat membuat checkout session dengan jumlah dinamis. Field amount dalam product cart memungkinkan Anda menetapkan harga secara terprogram untuk setiap checkout session.

​

Memahami Field Amount

Saat membuat checkout session, Anda dapat menyertakan field amount dalam setiap item product cart:

• Jika amount diberikan: Checkout menggunakan jumlah persis tersebut (harus berada dalam batas minimum/maksimum Anda)
• Jika amount tidak disertakan: Pelanggan dapat memasukkan harga mereka sendiri selama checkout (dalam batas yang Anda tetapkan)

Field amount hanya berlaku untuk produk Pay What You Want. Untuk produk biasa, field ini diabaikan.

​

Contoh Kode

TypeScript

import DodoPayments from 'dodopayments';

// Initialize the Dodo Payments client
const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
});

async function createDynamicPricingCheckout(
  productId: string,
  amountInCents: number,
  returnUrl: string
) {
  try {
    const session = await client.checkoutSessions.create({
      product_cart: [
        {
          product_id: productId,
          quantity: 1,
          // Dynamic amount in cents (e.g., 1500 = $15.00)
          amount: amountInCents
        }
      ],
      return_url: returnUrl,
      // Optional: Pre-fill customer information
      customer: {
        email: '[e-mail]',
        name: 'John Doe'
      },
      // Optional: Add metadata for tracking
      metadata: {
        order_id: 'order_123',
        pricing_tier: 'custom'
      }
    });

    console.log('Checkout URL:', session.checkout_url);
    console.log('Session ID:', session.session_id);
    
    return session;
  } catch (error) {
    console.error('Failed to create checkout session:', error);
    throw error;
  }
}

// Example: Create checkout with $25.00 (2500 cents)
const session = await createDynamicPricingCheckout(
  'prod_123abc456def',
  2500, // $25.00 in cents
  'https://yoursite.com/checkout/success'
);

// Example: Create checkout with $10.00 (1000 cents)
const session2 = await createDynamicPricingCheckout(
  'prod_123abc456def',
  1000, // $10.00 in cents
  'https://yoursite.com/checkout/success'
);

import os
from dodopayments import DodoPayments

# Initialize the Dodo Payments client
client = DodoPayments(
    bearer_token=os.environ.get("DODO_PAYMENTS_API_KEY"),
)

def create_dynamic_pricing_checkout(
    product_id: str,
    amount_in_cents: int,
    return_url: str
):
    """
    Create a checkout session with dynamic pricing.
    
    Args:
        product_id: The product ID with Pay What You Want enabled
        amount_in_cents: The amount in cents (e.g., 2500 for $25.00)
        return_url: URL to redirect after payment completion
    
    Returns:
        Session object with checkout_url and session_id
    """
    try:
        session = client.checkout_sessions.create(
            product_cart=[
                {
                    "product_id": product_id,
                    "quantity": 1,
                    # Dynamic amount in cents (e.g., 1500 = $15.00)
                    "amount": amount_in_cents
                }
            ],
            return_url=return_url,
            # Optional: Pre-fill customer information
            customer={
                "email": "[e-mail]",
                "name": "John Doe"
            },
            # Optional: Add metadata for tracking
            metadata={
                "order_id": "order_123",
                "pricing_tier": "custom"
            }
        )
        
        print(f"Checkout URL: {session.checkout_url}")
        print(f"Session ID: {session.session_id}")
        
        return session
    except Exception as error:
        print(f"Failed to create checkout session: {error}")
        raise error

# Example: Create checkout with $25.00 (2500 cents)
session = create_dynamic_pricing_checkout(
    "prod_123abc456def",
    2500,  # $25.00 in cents
    "https://yoursite.com/checkout/success"
)

# Example: Create checkout with $10.00 (1000 cents)
session2 = create_dynamic_pricing_checkout(
    "prod_123abc456def",
    1000,  # $10.00 in cents
    "https://yoursite.com/checkout/success"
)

Format Amount: Field amount harus menggunakan denominasi terendah dari mata uang. Untuk USD, berarti sen (misalnya, $25.00 = 2500). Untuk mata uang lain, gunakan unit terkecil (misalnya, paise untuk INR).

​

Langkah 3: Biarkan Pelanggan Memilih Harga Mereka

Jika Anda ingin pelanggan memilih harga mereka sendiri selama checkout, cukup hilangkan field amount dari product cart. Halaman checkout akan menampilkan field input tempat pelanggan dapat memasukkan jumlah apa pun dalam batas minimum dan maksimum Anda.

TypeScript

async function createCustomerChoiceCheckout(
  productId: string,
  returnUrl: string
) {
  try {
    const session = await client.checkoutSessions.create({
      product_cart: [
        {
          product_id: productId,
          quantity: 1
          // No amount field - customer will choose their price
        }
      ],
      return_url: returnUrl,
      customer: {
        email: '[e-mail]',
        name: 'John Doe'
      }
    });

    return session;
  } catch (error) {
    console.error('Failed to create checkout session:', error);
    throw error;
  }
}

def create_customer_choice_checkout(
    product_id: str,
    return_url: str
):
    """
    Create a checkout session where customers choose their own price.
    """
    try:
        session = client.checkout_sessions.create(
            product_cart=[
                {
                    "product_id": product_id,
                    "quantity": 1
                    # No amount field - customer will choose their price
                }
            ],
            return_url=return_url,
            customer={
                "email": "[e-mail]",
                "name": "John Doe"
            }
        )
        
        return session
    except Exception as error:
        print(f"Failed to create checkout session: {error}")
        raise error

​

Kasus Penggunaan Umum

​

Kasus Penggunaan 1: Harga Bertingkat Berdasarkan Jenis Pengguna

Tawarkan harga berbeda kepada segmen pelanggan yang berbeda menggunakan produk yang sama:

// Student discount: $10.00
const studentSession = await createDynamicPricingCheckout(
  'prod_123abc456def',
  1000, // $10.00
  'https://yoursite.com/success'
);

// Regular price: $25.00
const regularSession = await createDynamicPricingCheckout(
  'prod_123abc456def',
  2500, // $25.00
  'https://yoursite.com/success'
);

// Premium price: $50.00
const premiumSession = await createDynamicPricingCheckout(
  'prod_123abc456def',
  5000, // $50.00
  'https://yoursite.com/success'
);

​

Kasus Penggunaan 2: Dynamic Pricing Berdasarkan Kuantitas

Sesuaikan harga berdasarkan kuantitas yang dibeli:

async function createQuantityBasedCheckout(
  productId: string,
  quantity: number
) {
  // Base price: $20.00 per unit
  // Discount: 10% for 2+ items, 20% for 5+ items
  const basePrice = 2000; // $20.00 in cents
  let discount = 0;
  
  if (quantity >= 5) {
    discount = 0.20; // 20% off
  } else if (quantity >= 2) {
    discount = 0.10; // 10% off
  }
  
  const totalAmount = Math.round(basePrice * quantity * (1 - discount));
  
  const session = await client.checkoutSessions.create({
    product_cart: [
      {
        product_id: productId,
        quantity: quantity,
        amount: totalAmount
      }
    ],
    return_url: 'https://yoursite.com/success'
  });
  
  return session;
}

​

Kasus Penggunaan 3: Harga Berdasarkan Waktu atau Promosi

Terapkan harga promosi selama periode tertentu:

async function createPromotionalCheckout(productId: string) {
  const isPromoActive = checkIfPromotionActive(); // Your logic
  const regularPrice = 3000; // $30.00
  const promoPrice = 2000; // $20.00
  
  const amount = isPromoActive ? promoPrice : regularPrice;
  
  const session = await client.checkoutSessions.create({
    product_cart: [
      {
        product_id: productId,
        quantity: 1,
        amount: amount
      }
    ],
    return_url: 'https://yoursite.com/success',
    metadata: {
      pricing_type: isPromoActive ? 'promotional' : 'regular'
    }
  });
  
  return session;
}

​

Praktik Terbaik

Set Reasonable Bounds

Pilih harga minimum yang menutupi biaya Anda sekaligus tetap terjangkau. Gunakan harga yang disarankan untuk membantu membentuk ekspektasi pelanggan.

Validate Amounts

Selalu validasi bahwa jumlah dinamis berada dalam batas minimum dan maksimum produk sebelum membuat checkout session.

Track Pricing Decisions

Gunakan metadata untuk melacak alasan jumlah tertentu dipilih (misalnya, pricing_tier, discount_code, user_segment).

Handle Edge Cases

Pastikan aplikasi Anda menangani kasus ketika jumlah melebihi batas maksimum atau berada di bawah batas minimum dengan baik.

​

Validasi dan Penanganan Error

Selalu validasi jumlah terhadap pengaturan minimum dan maksimum produk Anda:

TypeScript

async function createValidatedCheckout(
  productId: string,
  amountInCents: number,
  minAmount: number,
  maxAmount: number | null
) {
  // Validate minimum
  if (amountInCents < minAmount) {
    throw new Error(
      `Amount ${amountInCents} is below minimum ${minAmount}`
    );
  }
  
  // Validate maximum (if set)
  if (maxAmount !== null && amountInCents > maxAmount) {
    throw new Error(
      `Amount ${amountInCents} exceeds maximum ${maxAmount}`
    );
  }
  
  // Create checkout session
  return await client.checkoutSessions.create({
    product_cart: [
      {
        product_id: productId,
        quantity: 1,
        amount: amountInCents
      }
    ],
    return_url: 'https://yoursite.com/success'
  });
}

def create_validated_checkout(
    product_id: str,
    amount_in_cents: int,
    min_amount: int,
    max_amount: int | None
):
    """
    Create a checkout session with amount validation.
    """
    # Validate minimum
    if amount_in_cents < min_amount:
        raise ValueError(
            f"Amount {amount_in_cents} is below minimum {min_amount}"
        )
    
    # Validate maximum (if set)
    if max_amount is not None and amount_in_cents > max_amount:
        raise ValueError(
            f"Amount {amount_in_cents} exceeds maximum {max_amount}"
        )
    
    # Create checkout session
    return client.checkout_sessions.create(
        product_cart=[
            {
                "product_id": product_id,
                "quantity": 1,
                "amount": amount_in_cents
            }
        ],
        return_url="https://yoursite.com/success"
    )

​

Referensi API

Pay What You Want Feature

Pelajari lebih lanjut tentang model harga Pay What You Want dan kapabilitasnya.

Checkout Sessions Guide

Jelajahi fitur checkout session lanjutan dan opsi kustomisasi.

​

Pemecahan Masalah

Amount is being ignored

Jika field amount Anda diabaikan, pastikan bahwa:

• Produk telah mengaktifkan Pay What You Want di dashboard
• Produk merupakan produk Single Payment (satu kali), bukan subscription
• Jumlah menggunakan format yang benar (denominasi mata uang terendah, misalnya sen untuk USD)

Amount exceeds maximum or is below minimum

API akan menolak checkout session jika jumlah melanggar batas harga produk Anda. Selalu validasi jumlah sebelum membuat checkout session, atau biarkan pelanggan memilih harga mereka dengan menghilangkan field amount.

Customer can't enter their own price

Jika pelanggan tidak melihat field input harga, pastikan Anda telah menghilangkan field amount dari product cart. Jika amount diberikan, checkout akan menggunakan jumlah persis tersebut.