> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dodopayments.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Model Penagihan Hibrida

> Gabungkan beberapa mode penagihan untuk membuat strategi harga yang canggih: langganan + penggunaan, kursi + add-on, dasar + kelebihan penggunaan, dan lainnya.

<Info>
  Penagihan hibrida menggabungkan dua atau lebih model penagihan menjadi satu strategi harga. Dengan demikian, Anda dapat menangkap nilai dari berbagai dimensi—biaya berulang, penggunaan, kursi, dan fitur—sekaligus memberikan fleksibilitas dan prediktabilitas kepada pelanggan.
</Info>

<CardGroup cols={2}>
  <Card title="Usage-Based Billing" icon="chart-line" href="/features/usage-based-billing/introduction">
    Dasar untuk harga berbasis konsumsi.
  </Card>

  <Card title="Subscriptions" icon="repeat" href="/features/subscription">
    Dasar untuk penagihan berulang.
  </Card>

  <Card title="Add-ons" icon="puzzle" href="/features/addons">
    Perluas langganan dengan upgrade opsional.
  </Card>

  <Card title="Seat-Based Billing" icon="users" href="/features/seat-based-billing">
    Model harga per pengguna.
  </Card>
</CardGroup>

***

## Apa itu Penagihan Hibrida?

Penagihan hibrida menggabungkan beberapa dimensi harga ke dalam satu penawaran produk. Alih-alih memilih antara langganan tarif tetap ATAU harga berbasis penggunaan, Anda menggunakan keduanya secara bersamaan.

### Mengapa Menggunakan Penagihan Hibrida?

| Tujuan Bisnis                                          | Solusi Hibrida                                    |
| ------------------------------------------------------ | ------------------------------------------------- |
| Pendapatan yang dapat diprediksi + peluang pertumbuhan | Langganan dasar + kelebihan penggunaan            |
| Harga tim yang dapat diskalakan                        | Per kursi + add-on fitur                          |
| Mendapatkan pelanggan, memperluas layanan kemudian     | Biaya dasar rendah + biaya konsumsi               |
| Fleksibilitas perusahaan                               | Pengeluaran berkomitmen + biaya sesuai permintaan |
| Harga yang adil untuk penggunaan variabel              | Kuota yang disertakan + bayar sesuai penggunaan   |

### Pola Hibrida Umum

| Model                                          | Deskripsi                                              | Contoh                                                               | Dukungan Native      |
| ---------------------------------------------- | ------------------------------------------------------ | -------------------------------------------------------------------- | -------------------- |
| **1. Langganan + Penggunaan**                  | Biaya dasar + biaya konsumsi                           | \$49/bln + \$0.01/panggilan API setelah 10K gratis                   | ✅ Penuh              |
| **2. Langganan + Kursi**                       | Biaya platform + biaya per pengguna                    | \$99/bln + \$15/kursi                                                | ✅ Penuh              |
| **3. Langganan + Add-on Fitur**                | Paket inti + upgrade opsional                          | \$29/bln + \$19/bln analitik + \$9/bln akses API                     | ✅ Penuh              |
| **4. Kursi + Penggunaan**                      | Biaya per pengguna + kelebihan konsumsi                | \$10/pengguna/bln + \$0.05/GB setelah 5GB/pengguna                   | ⚠️ Solusi alternatif |
| **5. Langganan + Kursi + Penggunaan**          | Platform + pengguna + konsumsi (hibrida tiga komponen) | \$199/bln + \$20/kursi + kelebihan penggunaan                        | ⚠️ Solusi alternatif |
| **6. Dasar Bertingkat + Kelebihan Penggunaan** | Tingkatan berbeda dengan kuota berbeda                 | Starter (5K panggilan) vs Pro (50K panggilan) + kelebihan penggunaan | ✅ Penuh              |
| **7. Langganan + Biaya Sesuai Permintaan**     | Biaya berulang + biaya manual variabel                 | Retainer \$99/bln + penagihan per jam untuk pekerjaan                | ✅ Penuh              |

***

## Model Hibrida 1: Langganan + Penggunaan

Model hibrida yang paling umum. Pelanggan membayar biaya langganan dasar ditambah biaya untuk konsumsi yang melebihi kuota yang disertakan.

### Cara Kerjanya

**Paket Pro: \$49/bulan**

* **Termasuk**: 10.000 panggilan API/bulan
* **Kelebihan penggunaan**: \$0.005 per panggilan setelah 10.000

**Contoh perhitungan** (pelanggan menggunakan 25.000 panggilan bulan ini):

* Langganan dasar: \$49.00
* Kelebihan penggunaan: (25.000 - 10.000) × $0.005 = $75.00
* **Total: \$124.00**

### Kasus Penggunaan

* **Platform API**: Akses dasar + biaya per permintaan
* **Layanan AI/ML**: Langganan + penggunaan token/generasi
* **Layanan penyimpanan**: Paket dasar + kelebihan penggunaan per GB
* **Platform komunikasi**: Biaya dasar + biaya per pesan/menit

### Implementasi

<Steps>
  <Step title="Create Usage Meter">
    Siapkan meter untuk melacak dimensi penggunaan yang dapat ditagihkan.

    ```bash theme={null}
    Dashboard: Meters → Create Meter
    Event Name: "api.call"
    Aggregation: Count
    This tracks API calls per customer
    ```
  </Step>

  <Step title="Create Subscription Product with Usage Pricing">
    Buat produk langganan dan lampirkan meter penggunaan beserta harganya.

    ```bash theme={null}
    Dashboard: Create Product → Subscription
    Name: "Pro Plan"
    Base Price: $49/month

    Then attach usage pricing:
    - Meter: api.call
    - Price per unit: $0.005
    - Free threshold: 10,000 (included in subscription)
    ```

    <Info>
      Meter penggunaan dilampirkan langsung ke produk langganan. Biaya penggunaan dihitung dan ditambahkan ke invoice langganan secara otomatis.
    </Info>
  </Step>

  <Step title="Create Checkout Session">
    Buat sesi checkout dengan produk langganan Anda.

    ```typescript theme={null}
    const session = await client.checkoutSessions.create({
      product_cart: [
        { product_id: 'prod_pro_plan', quantity: 1 }
      ],
      customer: { email: 'customer@example.com' },
      return_url: 'https://yourapp.com/success'
    });
    ```
  </Step>

  <Step title="Send Usage Events">
    Lacak penggunaan selama periode penagihan.

    ```typescript theme={null}
    await fetch('https://test.dodopayments.com/events/ingest', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        events: [{
          event_id: `call_${Date.now()}`,
          customer_id: 'cus_123',
          event_name: 'api.call',
          timestamp: new Date().toISOString(),
          metadata: { endpoint: '/v1/generate' }
        }]
      })
    });
    ```
  </Step>
</Steps>

### Variasi Harga

<Tabs>
  <Tab title="Included Allowance">
    Ambang batas gratis mencakup penggunaan yang disertakan dalam langganan dasar.

    **Paket Pro: \$49/bulan**

    * Termasuk: 10.000 panggilan API
    * Kelebihan penggunaan: \$0.005/panggilan setelah 10.000
    * Pelanggan menggunakan 8.000 → Membayar \$49 (tanpa kelebihan penggunaan)
  </Tab>

  <Tab title="Zero Base + Pure Usage">
    Tidak ada biaya dasar; setiap unit dapat ditagihkan sejak penggunaan pertama.

    **Bayar Sesuai Penggunaan: dasar \$0/bulan**

    * Termasuk: 0 panggilan API
    * Penggunaan: \$0.01/panggilan sejak panggilan pertama
    * Pelanggan menggunakan 5.000 → Membayar \$50
  </Tab>

  <Tab title="Tiered Allowances">
    Tingkatan yang berbeda mencakup kuota yang berbeda.

    * **Starter**: \$19/bulan (termasuk 1.000 panggilan)
    * **Pro**: \$49/bulan (termasuk 10.000 panggilan)
    * **Enterprise**: \$199/bulan (termasuk 100.000 panggilan)
    * Semua tingkatan: kelebihan penggunaan \$0.005/panggilan
  </Tab>
</Tabs>

***

## Model Hibrida 2: Langganan + Kursi

Biaya platform ditambah biaya per pengguna. Ideal untuk alat kolaborasi tim dan SaaS B2B.

### Cara Kerjanya

**Paket Tim: $99/bulan + $15/kursi**

* **Biaya platform dasar**: \$99/bulan (termasuk 3 kursi)
* **Kursi tambahan**: \$15/kursi/bulan

**Contoh perhitungan** (tim yang terdiri dari 12 pengguna):

* Biaya platform: \$99.00
* Kursi tambahan: (12 - 3) × $15 = $135.00
* **Total: \$234.00/bulan**

### Kasus Penggunaan

* **Alat kolaborasi**: Biaya ruang kerja + per anggota
* **Sistem CRM**: Lisensi platform + per perwakilan penjualan
* **Manajemen proyek**: Paket tim + per kontributor
* **Alat developer**: Biaya organisasi + per developer

### Implementasi

<Steps>
  <Step title="Create Seat Add-on">
    Buat add-on untuk kursi tambahan.

    ```bash theme={null}
    Dashboard: Products → Add-ons → Create Add-on
    Name: "Additional Seat"
    Price: $15/month
    Description: "Add another team member"
    ```
  </Step>

  <Step title="Create Base Subscription">
    Buat produk langganan dengan biaya platform dan lampirkan add-on.

    ```bash theme={null}
    Dashboard: Create Product → Subscription
    Name: "Team Plan"
    Price: $99/month
    Description: "Includes 3 team members"

    Then in Add-ons section:
    - Attach: "Additional Seat" add-on
    ```
  </Step>

  <Step title="Create Checkout with Seats">
    Tentukan jumlah kursi selama checkout.

    ```typescript theme={null}
    const session = await client.checkoutSessions.create({
      product_cart: [{
        product_id: 'prod_team_plan',
        quantity: 1,
        addons: [{
          addon_id: 'addon_seat',
          quantity: 9  // 9 extra seats (12 total with 3 included)
        }]
      }],
      customer: { email: 'admin@company.com' },
      return_url: 'https://yourapp.com/success'
    });
    ```
  </Step>

  <Step title="Adjust Seats as Needed">
    Tambahkan atau hapus kursi pada langganan yang sudah ada.

    ```typescript theme={null}
    // Add 5 more seats
    await client.subscriptions.changePlan('sub_123', {
      product_id: 'prod_team_plan',
      quantity: 1,
      proration_billing_mode: 'prorated_immediately',
      addons: [{
        addon_id: 'addon_seat',
        quantity: 14  // New total: 14 extra seats
      }]
    });
    ```
  </Step>
</Steps>

### Variasi Harga

<Tabs>
  <Tab title="Included Seats">
    Paket dasar mencakup beberapa kursi; kenakan biaya untuk kursi tambahan.

    **Paket Tim: \$99/bulan**

    * Termasuk: 5 kursi
    * Kursi tambahan: \$15/kursi/bulan
    * 20 pengguna = \$99 + (15 × \$15) = \$324/bulan
  </Tab>

  <Tab title="Pure Per-Seat">
    Tidak ada biaya platform, hanya biaya per pengguna.

    **Per Pengguna: \$25/pengguna/bulan**

    * Tidak ada biaya platform
    * 5 pengguna = \$125/bulan
    * 50 pengguna = \$1.250/bulan

    Implementasi: Tetapkan harga langganan dasar sebesar \$0, lalu gunakan add-on kursi saja.
  </Tab>

  <Tab title="Tiered Per-Seat">
    Harga per kursi menurun pada tingkatan yang lebih tinggi.

    * **Starter**: \$20/kursi (1-10 kursi)
    * **Growth**: \$15/kursi (11-50 kursi)
    * **Enterprise**: \$10/kursi (51+ kursi)

    Implementasi: Buat produk langganan terpisah untuk setiap tingkatan dengan harga add-on yang berbeda.
  </Tab>
</Tabs>

***

## Model Hibrida 3: Langganan + Add-on Fitur

Langganan inti dengan upgrade fitur opsional yang dapat ditambahkan oleh pelanggan.

### Cara Kerjanya

**Paket Inti: \$29/bulan**

**Add-on Opsional:**

* Analitik Lanjutan: +\$19/bulan
* Akses API: +\$9/bulan
* Dukungan Prioritas: +\$29/bulan
* White-label: +\$49/bulan

**Contoh perhitungan** (pelanggan memilih Inti + Analitik + Akses API):

* Paket inti: \$29.00
* Analitik: \$19.00
* Akses API: \$9.00
* **Total: \$57.00/bulan**

### Kasus Penggunaan

* **Platform SaaS**: Fitur inti + modul premium
* **Alat pemasaran**: Alat dasar + integrasi
* **Produk analitik**: Dasbor + laporan lanjutan
* **Perangkat lunak keamanan**: Perlindungan dasar + fitur lanjutan

### Implementasi

<Steps>
  <Step title="Create Feature Add-ons">
    Buat add-on untuk setiap fitur opsional.

    ```bash theme={null}
    # Add-on 1: Advanced Analytics
    Dashboard: Products → Add-ons → Create Add-on
    Name: "Advanced Analytics"
    Price: $19/month

    # Add-on 2: API Access
    Name: "API Access"
    Price: $9/month

    # Add-on 3: Priority Support
    Name: "Priority Support"
    Price: $29/month

    # Add-on 4: White-label
    Name: "White-label"
    Price: $49/month
    ```
  </Step>

  <Step title="Create Core Subscription">
    Tentukan langganan dasar Anda dan lampirkan semua add-on fitur.

    ```bash theme={null}
    Dashboard: Create Product → Subscription
    Name: "Core Plan"
    Price: $29/month

    Then in Add-ons section:
    - Attach all feature add-ons
    ```
  </Step>

  <Step title="Let Customers Choose">
    Lakukan checkout dengan fitur yang dipilih.

    ```typescript theme={null}
    const session = await client.checkoutSessions.create({
      product_cart: [{
        product_id: 'prod_core_plan',
        quantity: 1,
        addons: [
          { addon_id: 'addon_analytics', quantity: 1 },
          { addon_id: 'addon_api_access', quantity: 1 }
          // Customer didn't select support or white-label
        ]
      }],
      return_url: 'https://yourapp.com/success'
    });
    ```
  </Step>

  <Step title="Add Features Later">
    Pelanggan dapat menambahkan fitur ke langganan yang sudah ada.

    ```typescript theme={null}
    // Customer wants to add Priority Support
    await client.subscriptions.changePlan('sub_123', {
      product_id: 'prod_core_plan',
      quantity: 1,
      proration_billing_mode: 'prorated_immediately',
      addons: [
        { addon_id: 'addon_analytics', quantity: 1 },
        { addon_id: 'addon_api_access', quantity: 1 },
        { addon_id: 'addon_priority_support', quantity: 1 }  // New!
      ]
    });
    ```
  </Step>
</Steps>

***

## Model Hibrida 4: Kursi + Penggunaan

Biaya per pengguna yang digabungkan dengan biaya berbasis konsumsi. Setiap pengguna mendapatkan kuota.

<Warning>
  **Batasan**: Dodo Payments saat ini tidak mendukung pelampiran meter penggunaan dan add-on secara bersamaan ke produk langganan yang sama. Model ini memerlukan solusi alternatif menggunakan logika tingkat aplikasi.
</Warning>

<Info>
  **Segera Hadir**: Dukungan native untuk penagihan hibrida Kursi + Penggunaan sedang dalam roadmap kami. Ini akan memungkinkan Anda melampirkan meter penggunaan dan add-on kursi ke produk langganan yang sama.
</Info>

### Cara Kerjanya

**Analitik Tim: \$20/pengguna/bulan**

**Setiap pengguna mendapatkan:**

* Pemrosesan data 5 GB/bulan
* Kelebihan penggunaan: \$2/GB setelah kuota

**Contoh perhitungan** (tim 10 pengguna menggunakan total 80 GB):

* Biaya kursi: 10 × $20 = $200.00
* Data yang disertakan: 10 × 5 GB = 50 GB
* Kelebihan penggunaan: (80 - 50) × $2 = $60.00
* **Total: \$260.00/bulan**

### Kasus Penggunaan

* **Platform analitik**: Per analis + pemrosesan data
* **Alat desain**: Per desainer + penyimpanan/ekspor
* **Lingkungan pengembangan**: Per developer + jam komputasi
* **Alat komunikasi**: Per pengguna + volume pesan/panggilan

### Opsi Implementasi

Karena Anda tidak dapat melampirkan meter penggunaan dan add-on ke langganan yang sama, pilih salah satu pendekatan berikut:

<Tabs>
  <Tab title="Option A: Usage Product + App-Managed Seats">
    Gunakan langganan berbasis penggunaan dan kelola penagihan kursi di aplikasi Anda.

    <Steps>
      <Step title="Create Usage Meter">
        ```bash theme={null}
        Dashboard: Meters → Create Meter
        Event Name: "data.processed"
        Aggregation: Sum
        Property: "bytes"
        ```
      </Step>

      <Step title="Create Usage-Based Subscription">
        ```bash theme={null}
        Dashboard: Create Product → Subscription
        Name: "Team Analytics"
        Base Price: $0/month

        Attach usage pricing:
        - Meter: data.processed
        - Price per unit: $2/GB
        - Free threshold: 0 (managed by your app)
        ```
      </Step>

      <Step title="Manage Seats in Your Application">
        Lacak jumlah kursi dan hitung biaya kursi secara terpisah.

        ```typescript theme={null}
        // Your application tracks seats and calculates total cost
        async function calculateMonthlyBill(customerId: string) {
          const seatCount = await getSeatCount(customerId);
          const seatFee = seatCount * 20; // $20/seat

          // Usage is billed by Dodo automatically
          // You invoice/charge seat fees separately or include in base price

          // Alternatively, adjust base subscription price when seats change
          const totalBasePrice = seatCount * 2000; // $20/seat in cents
          await client.subscriptions.update('sub_123', {
            // Update subscription to reflect seat-based pricing
          });
        }
        ```
      </Step>

      <Step title="Calculate Dynamic Free Threshold">
        Sesuaikan penggunaan yang disertakan berdasarkan jumlah kursi.

        ```typescript theme={null}
        // When checking usage, apply per-seat allowance
        async function checkUsageOverage(customerId: string) {
          const seatCount = await getSeatCount(customerId);
          const includedGB = seatCount * 5; // 5 GB per user

          const currentUsage = await getUsageFromDodo(customerId);
          const overage = Math.max(0, currentUsage - includedGB);

          // Overage is billed by Dodo at $2/GB
          return { included: includedGB, used: currentUsage, overage };
        }
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Option B: Seat Add-on + On-Demand Usage Charges">
    Gunakan add-on untuk kursi dan kenakan biaya penggunaan secara manual melalui biaya sesuai permintaan.

    <Steps>
      <Step title="Create Seat Add-on">
        ```bash theme={null}
        Dashboard: Products → Add-ons → Create Add-on
        Name: "Team Member"
        Price: $20/month
        ```
      </Step>

      <Step title="Create Subscription with Add-on">
        ```bash theme={null}
        Dashboard: Create Product → Subscription
        Name: "Team Analytics"
        Base Price: $0/month

        Attach add-on:
        - "Team Member" add-on

        Enable on-demand charging
        ```
      </Step>

      <Step title="Track Usage in Your Application">
        ```typescript theme={null}
        // Track usage events in your system
        async function trackDataProcessed(customerId: string, bytes: number) {
          await saveUsageEvent({
            customer_id: customerId,
            event_type: 'data.processed',
            bytes: bytes,
            timestamp: new Date()
          });
        }
        ```
      </Step>

      <Step title="Charge Usage at End of Cycle">
        Hitung dan kenakan biaya kelebihan penggunaan secara manual.

        ```typescript theme={null}
        async function billUsageOverage(subscriptionId: string) {
          const subscription = await getSubscription(subscriptionId);
          const seatCount = subscription.addons.find(a => a.id === 'addon_seat')?.quantity || 0;

          const includedGB = seatCount * 5;
          const usedGB = await calculatePeriodUsage(subscription.customer_id);
          const overageGB = Math.max(0, usedGB - includedGB);

          if (overageGB > 0) {
            const overageCharge = overageGB * 200; // $2/GB in cents
            await client.subscriptions.charge(subscriptionId, {
              product_price: overageCharge,
              product_description: `Data overage: ${overageGB} GB × $2/GB`
            });
          }
        }
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

<Info>
  **Rekomendasi**: Opsi B (Add-on Kursi + Penggunaan Sesuai Permintaan) sering kali lebih mudah diimplementasikan karena Dodo menangani penagihan kursi secara otomatis. Anda hanya perlu melacak dan mengenakan biaya kelebihan penggunaan.
</Info>

***

## Model Hibrida 5: Langganan + Kursi + Penggunaan (Hibrida Tiga Komponen)

Model paling komprehensif: biaya platform + per pengguna + konsumsi.

<Warning>
  **Batasan**: Dodo Payments saat ini tidak mendukung pelampiran meter penggunaan dan add-on secara bersamaan ke produk langganan yang sama. Model ini memerlukan solusi alternatif.
</Warning>

<Info>
  **Segera Hadir**: Dukungan native untuk penagihan Hibrida Tiga Komponen (Dasar + Kursi + Penggunaan) sedang dalam roadmap kami. Ini akan memungkinkan Anda melampirkan meter penggunaan dan add-on kursi ke produk langganan yang sama.
</Info>

### Cara Kerjanya

**Platform Enterprise**

* **Biaya Platform**: \$199/bulan
* **Per Kursi**: \$25/pengguna/bulan
* **Penggunaan**: \$0.10/1.000 panggilan API (50K disertakan)

**Contoh perhitungan** (perusahaan dengan 20 pengguna, 150.000 panggilan API):

* Platform: \$199.00
* Kursi: 20 × $25 = $500.00
* Penggunaan: (150K - 50K) × \$0.10/1K = \$10.00
* **Total: \$709.00/bulan**

### Kasus Penggunaan

* **SaaS Enterprise**: Platform + tim + konsumsi
* **Platform data**: Ruang kerja + analis + kueri
* **Platform integrasi**: Hub + konektor + transaksi
* **Platform AI**: Ruang kerja + developer + inferensi

### Opsi Implementasi

Pilih salah satu pendekatan berikut untuk mengimplementasikan penagihan hibrida tiga komponen:

<Tabs>
  <Tab title="Option A: Base + Seats (Add-on) + On-Demand Usage">
    Gunakan langganan dengan add-on kursi, lalu kenakan biaya penggunaan secara manual melalui biaya sesuai permintaan.

    **Ini adalah pendekatan yang direkomendasikan** karena Dodo menangani biaya platform dan penagihan kursi secara otomatis.

    <Steps>
      <Step title="Create Seat Add-on">
        ```bash theme={null}
        Dashboard: Products → Add-ons → Create Add-on
        Name: "User Seat"
        Price: $25/month
        ```
      </Step>

      <Step title="Create Subscription Product">
        ```bash theme={null}
        Dashboard: Create Product → Subscription
        Name: "Enterprise Platform"
        Base Price: $199/month

        Attach add-on:
        - "User Seat" add-on

        Enable on-demand charging
        ```
      </Step>

      <Step title="Create Checkout with Seats">
        ```typescript theme={null}
        const session = await client.checkoutSessions.create({
          product_cart: [{
            product_id: 'prod_enterprise_platform',
            quantity: 1,
            addons: [{
              addon_id: 'addon_user_seat',
              quantity: 20  // 20 users
            }]
          }],
          customer: { email: 'enterprise@company.com' },
          return_url: 'https://yourapp.com/success'
        });
        ```
      </Step>

      <Step title="Track Usage in Your Application">
        Simpan event penggunaan di sistem Anda.

        ```typescript theme={null}
        // Track API calls in your system
        async function trackApiCall(customerId: string, endpoint: string) {
          await saveUsageEvent({
            customer_id: customerId,
            event_type: 'api.call',
            endpoint: endpoint,
            timestamp: new Date()
          });
        }
        ```
      </Step>

      <Step title="Charge Usage at End of Cycle">
        Hitung dan kenakan biaya kelebihan penggunaan melalui biaya sesuai permintaan.

        ```typescript theme={null}
        async function billUsageOverage(subscriptionId: string) {
          const usage = await calculatePeriodUsage(subscriptionId);
          const includedCalls = 50000;
          const overageCalls = Math.max(0, usage.totalCalls - includedCalls);

          if (overageCalls > 0) {
            // $0.10 per 1000 calls = $0.0001 per call
            const overageCharge = Math.ceil(overageCalls / 1000) * 10; // cents
            await client.subscriptions.charge(subscriptionId, {
              product_price: overageCharge,
              product_description: `API usage: ${overageCalls.toLocaleString()} calls over 50K included`
            });
          }
        }
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Option B: Base + Usage (Meter) + App-Managed Seats">
    Gunakan langganan dengan meter penggunaan, lalu kelola penagihan kursi di aplikasi Anda.

    <Steps>
      <Step title="Create Usage Meter">
        ```bash theme={null}
        Dashboard: Meters → Create Meter
        Event Name: "api.call"
        Aggregation: Count
        ```
      </Step>

      <Step title="Create Subscription Product with Usage">
        ```bash theme={null}
        Dashboard: Create Product → Subscription
        Name: "Enterprise Platform"
        Base Price: $199/month

        Attach usage pricing:
        - Meter: api.call
        - Price: $0.10 per 1000 calls
        - Free threshold: 50,000
        ```
      </Step>

      <Step title="Manage Seats in Your Application">
        Lacak jumlah kursi dan sesuaikan harga langganan dasar secara proporsional.

        ```typescript theme={null}
        // When seats change, update subscription price
        async function updateSeatCount(subscriptionId: string, newSeatCount: number) {
          const basePlatformFee = 19900; // $199 in cents
          const perSeatFee = 2500; // $25 in cents
          const totalPrice = basePlatformFee + (newSeatCount * perSeatFee);

          // Store seat count in your system
          await updateSeatsInDatabase(subscriptionId, newSeatCount);

          // Note: You may need to handle this via plan changes or
          // create multiple tier products for common seat counts
        }
        ```
      </Step>

      <Step title="Send Usage Events to Dodo">
        ```typescript theme={null}
        await fetch('https://test.dodopayments.com/events/ingest', {
          method: 'POST',
          headers: {
            'Authorization': `Bearer ${apiKey}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            events: [{
              event_id: `api_${Date.now()}`,
              customer_id: 'cus_enterprise',
              event_name: 'api.call',
              timestamp: new Date().toISOString()
            }]
          })
        });
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

<Info>
  **Rekomendasi**: Opsi A (Dasar + Kursi + Penggunaan Sesuai Permintaan) umumnya lebih mudah karena Dodo menangani penagihan platform dan kursi secara otomatis. Anda hanya perlu melacak penggunaan dan mengirimkan biaya pada akhir setiap siklus penagihan.
</Info>

***

## Model Hibrida 6: Dasar Bertingkat + Kelebihan Penggunaan

Tingkatan langganan yang berbeda dengan kuota dan tarif kelebihan penggunaan yang berbeda.

### Cara Kerjanya

| Tingkatan      | Harga       | Panggilan yang Disertakan | Tarif Kelebihan Penggunaan |
| -------------- | ----------- | ------------------------- | -------------------------- |
| **Starter**    | \$19/bulan  | 1.000                     | \$0.02/panggilan           |
| **Pro**        | \$79/bulan  | 25.000                    | \$0.01/panggilan           |
| **Business**   | \$199/bulan | 100.000                   | \$0.005/panggilan          |
| **Enterprise** | \$499/bulan | 500.000                   | \$0.002/panggilan          |

### Implementasi

Buat produk langganan terpisah untuk setiap tingkatan, masing-masing dengan konfigurasi penggunaannya sendiri:

```bash theme={null}
# For each tier, create a subscription product:

# Starter Tier
Dashboard: Create Product → Subscription
Name: "Starter"
Base Price: $19/month
Usage Pricing:
- Meter: api.call
- Price: $0.02/call
- Free threshold: 1,000

# Pro Tier
Name: "Pro"
Base Price: $79/month
Usage Pricing:
- Meter: api.call
- Price: $0.01/call
- Free threshold: 25,000

# ... and so on for Business and Enterprise
```

### Jalur Upgrade

Saat pelanggan melakukan upgrade tingkatan, mereka mendapatkan:

* Kuota yang disertakan lebih tinggi
* Tarif kelebihan penggunaan lebih rendah
* Nilai lebih besar untuk setiap dolar

```typescript theme={null}
// Customer upgrades from Starter to Pro
await client.subscriptions.changePlan('sub_123', {
  product_id: 'prod_pro',
  quantity: 1,
  proration_billing_mode: 'prorated_immediately'
});
```

***

## Model Hibrida 7: Langganan + Biaya Sesuai Permintaan

Langganan berulang ditambah biaya manual variabel untuk layanan atau kelebihan penggunaan.

### Cara Kerjanya

**Paket Retainer: \$199/bulan**

**Termasuk:**

* Akses platform
* 5 jam konsultasi/bulan
* Dukungan email

**Biaya Sesuai Permintaan (sesuai kebutuhan):**

* Konsultasi tambahan: \$150/jam
* Pengembangan khusus: \$200/jam
* Dukungan darurat: \$100/insiden

**Contoh perhitungan** (bulan ini):

* Retainer: \$199.00
* 3 jam konsultasi tambahan: \$450.00
* 1 dukungan darurat: \$100.00
* **Total: \$749.00**

### Kasus Penggunaan

* **Layanan konsultasi**: Retainer + penagihan per jam
* **Layanan terkelola**: Biaya dasar + biaya insiden
* **Layanan agensi**: Biaya bulanan + biaya proyek
* **Paket dukungan**: Biaya SLA + per tiket atau per jam

### Implementasi

<Steps>
  <Step title="Create On-Demand Subscription">
    Siapkan langganan dengan penagihan sesuai permintaan yang diaktifkan.

    ```typescript theme={null}
    const subscription = await client.subscriptions.create({
      billing: {
        city: 'San Francisco',
        country: 'US',
        state: 'CA',
        street: '123 Main St',
        zipcode: '94105'
      },
      customer: { customer_id: 'cus_123' },
      product_id: 'prod_retainer',
      quantity: 1,
      payment_link: true,
      return_url: 'https://yourapp.com/success',
      on_demand: {
        mandate_only: false,
        product_price: 19900  // $199 initial charge
      }
    });
    ```
  </Step>

  <Step title="Charge for Services">
    Buat biaya saat layanan diberikan.

    ```typescript theme={null}
    // Charge for 3 hours of consulting
    await client.subscriptions.charge('sub_123', {
      product_price: 45000,  // $450.00 (3 × $150)
      product_description: 'Consulting - 3 hours (March 15)'
    });

    // Charge for emergency support incident
    await client.subscriptions.charge('sub_123', {
      product_price: 10000,  // $100.00
      product_description: 'Emergency support - Server outage (March 18)'
    });
    ```
  </Step>

  <Step title="Track and Invoice">
    Semua biaya muncul pada invoice pelanggan.

    ```typescript theme={null}
    // Retrieve subscription charges
    const payments = await client.payments.list({
      subscription_id: 'sub_123'
    });

    // Show itemized breakdown to customer
    payments.items.forEach(payment => {
      console.log(`${payment.description}: $${payment.amount / 100}`);
    });
    ```
  </Step>
</Steps>

***

## Contoh di Dunia Nyata

<Info>
  Contoh-contoh ini menunjukkan struktur harga yang ideal. Karena meter penggunaan dan add-on tidak dapat dilampirkan ke produk yang sama, beberapa kombinasi memerlukan solusi alternatif (menggunakan biaya sesuai permintaan untuk penggunaan atau kursi yang dikelola aplikasi).
</Info>

### Contoh 1: Platform AI SaaS

**Struktur Harga:**

* **Langganan Dasar**: \$99/bulan (akses platform, termasuk 5 kursi)
* **Add-on Kursi**: \$20/kursi/bulan
* **Add-on Fitur**: Model Khusus (\$49/bln), Akses API (\$29/bln), Antrean Prioritas (\$19/bln)
* **Kelebihan Penggunaan**: \$0.02 per 1.000 token setelah 100K (ditagihkan melalui biaya sesuai permintaan)

**Implementasi**: Gunakan langganan dengan add-on kursi dan fitur. Lacak penggunaan token di aplikasi Anda dan kenakan biaya kelebihan penggunaan melalui biaya sesuai permintaan pada akhir siklus penagihan.

**Contoh Pelanggan** (12 pengguna, 500K token, Model Khusus + Akses API):

| Komponen        | Perhitungan                          | Jumlah          |
| --------------- | ------------------------------------ | --------------- |
| Dasar           | Biaya platform                       | \$99            |
| Kursi tambahan  | 7 × \$20                             | \$140           |
| Model Khusus    | Add-on                               | \$49            |
| Akses API       | Add-on                               | \$29            |
| Kelebihan token | 400K × \$0.02/1K (sesuai permintaan) | \$8             |
| **Total**       |                                      | **\$325/bulan** |

### Contoh 2: Platform Alat Developer

**Opsi Tingkatan:**

|                 | Gratis    | Pro        | Enterprise     |
| --------------- | --------- | ---------- | -------------- |
| **Harga**       | \$0/bulan | \$29/bulan | \$199/bulan    |
| **Pengguna**    | 1         | 5 termasuk | Tidak terbatas |
| **Build**       | 100       | 1.000      | 10.000         |
| **Penyimpanan** | 1 GB      | 10 GB      | 100 GB         |

**Opsi Implementasi**:

**Opsi A** (Berfokus pada Penggunaan): Buat produk dengan meter penggunaan untuk build/penyimpanan. Kelola pengguna di aplikasi Anda.

**Opsi B** (Berfokus pada Kursi): Buat produk dengan add-on kursi. Lacak penggunaan build/penyimpanan dan kenakan biaya kelebihan penggunaan melalui biaya sesuai permintaan.

**Add-on (jika menggunakan Opsi B):**

* Pengguna tambahan: \$10/pengguna/bulan
* Build prioritas: \$19/bulan
* Domain khusus: \$9/domain/bulan

### Contoh 3: Otomasi Pemasaran

**Struktur Harga:**

* **Dasar**: \$79/bulan (fitur otomasi inti, termasuk 3 kursi)
* **Tingkatan Kontak** (add-on): 1K termasuk, 5K (+\$30), 25K (+\$80), 100K (+\$200)
* **Add-on Fitur**: Pemasaran SMS (\$29/bln), Landing Page (\$19/bln), Pengujian A/B (\$29/bln)
* **Kursi Tim**: add-on \$15/pengguna/bulan
* **Volume Email**: Lacak di aplikasi, kenakan biaya kelebihan penggunaan melalui biaya sesuai permintaan (\$1/1.000 email di atas batas)

**Implementasi**: Gunakan langganan dengan add-on tingkatan kontak, add-on fitur, dan add-on kursi. Lacak pengiriman email di aplikasi Anda dan kenakan biaya kelebihan penggunaan melalui biaya sesuai permintaan.

***

## Praktik Terbaik Implementasi

### Kejelasan Halaman Harga

<Tip>
  Buat harga hibrida mudah dipahami. Tampilkan biaya dasar, hal-hal yang termasuk, dan cara kerja kelebihan penggunaan secara jelas di halaman harga Anda.
</Tip>

**Baik**: "\$49/bulan termasuk 10.000 panggilan API. Panggilan tambahan: \$0.005 per panggilan"

**Buruk**: "\$49/bulan + biaya penggunaan"

### Prediktabilitas Biaya

Bantu pelanggan memperkirakan biaya mereka:

```typescript theme={null}
// Provide a cost calculator
function estimateMonthlyCost({
  plan,
  seats,
  expectedUsage,
  addons
}: EstimateParams): number {
  let total = plan.basePrice;

  // Add seat costs
  const extraSeats = Math.max(0, seats - plan.includedSeats);
  total += extraSeats * plan.seatPrice;

  // Add usage overage
  const overage = Math.max(0, expectedUsage - plan.includedUsage);
  total += overage * plan.overageRate;

  // Add feature add-ons
  total += addons.reduce((sum, addon) => sum + addon.price, 0);

  return total;
}
```

### Visibilitas Penggunaan

Tampilkan penggunaan pelanggan secara real-time:

```typescript theme={null}
// Display usage dashboard
async function getUsageSummary(subscriptionId: string) {
  const usage = await client.subscriptions.retrieveUsageHistory(subscriptionId);

  // Each item is a billing period; each meter reports its usage for that period.
  const latestPeriod = usage.items[0];

  return latestPeriod.meters.map((meter) => {
    const consumed = Number(meter.consumed_units);
    const chargeable = Number(meter.chargeable_units);
    return {
      meter: meter.name,
      current: consumed,
      included: meter.free_threshold,
      remaining: Math.max(0, meter.free_threshold - consumed),
      overage: chargeable,
      cost: meter.total_price
    };
  });
}
```

### Transparansi Penagihan

Sediakan invoice terperinci yang menampilkan semua komponen:

| Item Baris                                              | Jumlah       |
| ------------------------------------------------------- | ------------ |
| Paket Pro (Bulanan)                                     | \$49.00      |
| Kursi Tambahan (7 × \$15.00)                            | \$105.00     |
| Penggunaan API - Termasuk (10.000 panggilan)            | \$0.00       |
| Penggunaan API - Kelebihan (15.420 panggilan × \$0.005) | \$77.10      |
| Add-on Analitik Lanjutan                                | \$19.00      |
| **Subtotal**                                            | **\$250.10** |
| Pajak (8.5%)                                            | \$21.26      |
| **Total Terutang**                                      | **\$271.36** |

***

## Pemecahan Masalah Penagihan Hibrida

<AccordionGroup>
  <Accordion title="Usage not being tracked correctly">
    **Gejala**: Penggunaan menunjukkan nilai 0 atau nilai yang salah.

    **Solusi**:

    1. Verifikasi bahwa ingestion event berfungsi (periksa respons API)
    2. Pastikan `customer_id` cocok dengan pelanggan langganan
    3. Periksa apakah `event_name` cocok dengan konfigurasi meter
    4. Verifikasi bahwa event memiliki timestamp yang benar (bukan tanggal di masa depan)
  </Accordion>

  <Accordion title="Proration confusion with multiple components">
    **Gejala**: Pelanggan dikenai jumlah yang tidak terduga saat mengubah paket.

    **Solusi**:

    1. Gunakan API `previewChangePlan` untuk menampilkan biaya yang tepat sebelum mengonfirmasi
    2. Komunikasikan bahwa prorata berlaku untuk langganan DAN add-on
    3. Pertimbangkan menggunakan `difference_immediately` untuk penagihan upgrade yang lebih sederhana
  </Accordion>

  <Accordion title="Free threshold not applying correctly">
    **Gejala**: Pelanggan dikenai biaya untuk penggunaan yang seharusnya gratis.

    **Solusi**:

    1. Verifikasi bahwa ambang batas gratis dikonfigurasi pada produk berbasis penggunaan
    2. Periksa apakah unit ambang batas cocok dengan agregasi event (panggilan vs. permintaan)
    3. Pastikan meter penggunaan terlampir dengan benar ke produk langganan
  </Accordion>

  <Accordion title="Add-ons not appearing in checkout">
    **Gejala**: Tidak dapat menambahkan kursi atau fitur selama checkout.

    **Solusi**:

    1. Verifikasi bahwa add-on terlampir ke produk langganan di dasbor
    2. Periksa apakah ID add-on sudah benar dalam panggilan API
    3. Pastikan mata uang add-on cocok dengan mata uang produk langganan
  </Accordion>
</AccordionGroup>

***

## Dokumentasi Terkait

<CardGroup cols={2}>
  <Card title="Products" icon="box" href="/features/products">
    Ringkasan semua jenis produk dan panduan.
  </Card>

  <Card title="Usage-Based Billing Guide" icon="chart-line" href="/developer-resources/usage-based-billing-guide">
    Implementasi penagihan penggunaan lengkap.
  </Card>

  <Card title="Subscription Management" icon="repeat" href="/features/subscription">
    Mengelola langganan berulang.
  </Card>

  <Card title="Add-ons" icon="puzzle" href="/features/addons">
    Memperluas langganan dengan add-on.
  </Card>
</CardGroup>