हाइब्रिड Billing Models - Dodo Payments Documentation

हाइब्रिड billing दो या अधिक billing models को एक pricing strategy में मिलाती है। इससे आप अलग-अलग आयामों—recurring fees, usage, seats और features—से value प्राप्त कर सकते हैं और ग्राहकों को flexibility और predictability दे सकते हैं।

Usage-Based Billing

consumption-based pricing का आधार।

Subscriptions

recurring billing का आधार।

Add-ons

optional upgrades के साथ subscriptions का विस्तार करें।

Seat-Based Billing

per-user pricing models।

हाइब्रिड Billing क्या है?

हाइब्रिड billing कई pricing dimensions को एक product offering में मिलाती है। Flat-rate subscriptions और usage-based pricing में से किसी एक को चुनने के बजाय, आप दोनों का एक साथ उपयोग करते हैं।

हाइब्रिड Billing का उपयोग क्यों करें?

Business Goal	Hybrid Solution
Predictable revenue + growth upside	Base subscription + usage overage
Team pricing that scales	Per-seat + feature add-ons
Land customers, expand later	Low base fee + consumption charges
Enterprise flexibility	Committed spend + on-demand charges
Fair pricing for variable usage	Included allowance + pay-per-use

सामान्य हाइब्रिड Patterns

Model	Description	Example	Native Support
1. Subscription + Usage	Base fee + consumption charges	$49/mo + $0.01/API call after 10K free	✅ Full
2. Subscription + Seats	Platform fee + per-user charges	$99/mo + $15/seat	✅ Full
3. Subscription + Feature Add-ons	Core plan + optional upgrades	$29/mo + $19/mo analytics + $9/mo API access	✅ Full
4. Seats + Usage	Per-user fee + consumption overage	$10/user/mo + $0.05/GB after 5GB/user	⚠️ Workaround
5. Subscription + Seats + Usage	Platform + users + consumption (triple hybrid)	$199/mo + $20/seat + usage overage	⚠️ Workaround
6. Tiered Base + Usage Overage	Different tiers with different allowances	Starter (5K calls) vs Pro (50K calls) + overage	✅ Full
7. Subscription + On-Demand Charges	Recurring fee + variable manual charges	$99/mo retainer + hourly billing for work	✅ Full

हाइब्रिड Model 1: Subscription + Usage

यह सबसे सामान्य हाइब्रिड model है। ग्राहक base subscription fee के साथ included allowances से अधिक consumption के लिए charges का भुगतान करते हैं।

यह कैसे काम करता है

Pro Plan: $49/month

Included: 10,000 API calls/month
Overage: 10,000 के बाद प्रति call $0.005

Example calculation (ग्राहक इस महीने 25,000 calls का उपयोग करता है):

Base subscription: $49.00
Overage: (25,000 - 10,000) × $0.005 =$ 75.00
Total: $124.00

Use Cases

API platforms: Base access + per-request charges
AI/ML services: Subscription + token/generation usage
Storage services: Base plan + per-GB overage
Communication platforms: Base + per-message/minute charges

Implementation

Create Usage Meter

Billable usage dimension को track करने के लिए meter सेट अप करें।

Dashboard: Meters → Create Meter
Event Name: "api.call"
Aggregation: Count
This tracks API calls per customer

Create Subscription Product with Usage Pricing

Subscription product बनाएँ और pricing के साथ usage meter attach करें।

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)

Usage meter सीधे subscription product से attach होता है। Usage charges की गणना करके उन्हें subscription invoice में अपने-आप जोड़ दिया जाता है।

Create Checkout Session

अपने subscription product के साथ checkout session बनाएँ।

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

Send Usage Events

Billing period के दौरान usage track करें।

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' }
    }]
  })
});

Pricing Variations

Included Allowance
Zero Base + Pure Usage
Tiered Allowances

Free threshold base subscription में included usage को cover करता है।Pro Plan: $49/month

Includes: 10,000 API calls
Overage: 10,000 के बाद $0.005/call
ग्राहक 8,000 का उपयोग करता है → $49 का भुगतान (कोई overage नहीं)

हाइब्रिड Model 2: Subscription + Seats

Platform fee के साथ per-user charges। Team collaboration tools और B2B SaaS के लिए उपयुक्त।

यह कैसे काम करता है

Team Plan: $99/month +$ 15/seat

Base platform fee: $99/month (3 seats included)
Additional seats: $15/seat/month

Example calculation (12 users की team):

Platform fee: $99.00
Extra seats: (12 - 3) × $15 =$ 135.00
Total: $234.00/month

Use Cases

Collaboration tools: Workspace fee + per-member
CRM systems: Platform license + per-sales-rep
Project management: Team plan + per-contributor
Developer tools: Organization fee + per-developer

Implementation

Create Seat Add-on

Additional seats के लिए add-on बनाएँ।

Dashboard: Products → Add-ons → Create Add-on
Name: "Additional Seat"
Price: $15/month
Description: "Add another team member"

Create Base Subscription

Platform fee के साथ subscription product बनाएँ और add-on attach करें।

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

Create Checkout with Seats

Checkout के दौरान seat quantity निर्दिष्ट करें।

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

Adjust Seats as Needed

मौजूदा subscriptions में seats जोड़ें या हटाएँ।

// 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
  }]
});

Pricing Variations

Included Seats
Pure Per-Seat
Tiered Per-Seat

Base plan में कुछ seats शामिल हैं; अतिरिक्त seats के लिए charge करें।Team Plan: $99/month

Includes: 5 seats
Extra seats: $15/seat/month
20 users = $99 + (15 × $15) = $324/month

हाइब्रिड Model 3: Subscription + Feature Add-ons

Optional feature upgrades वाली core subscription, जिन्हें ग्राहक जोड़ सकते हैं।

यह कैसे काम करता है

Core Plan: $29/month Optional Add-ons:

Advanced Analytics: +$19/month
API Access: +$9/month
Priority Support: +$29/month
White-label: +$49/month

Example calculation (ग्राहक Core + Analytics + API Access चुनता है):

Core plan: $29.00
Analytics: $19.00
API Access: $9.00
Total: $57.00/month

Use Cases

SaaS platforms: Core features + premium modules
Marketing tools: Base tool + integrations
Analytics products: Dashboard + advanced reports
Security software: Basic protection + advanced features

Implementation

Create Feature Add-ons

प्रत्येक optional feature के लिए एक add-on बनाएँ।

# 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

Create Core Subscription

अपनी base subscription define करें और सभी feature add-ons attach करें।

Dashboard: Create Product → Subscription
Name: "Core Plan"
Price: $29/month

Then in Add-ons section:
- Attach all feature add-ons

Let Customers Choose

चुने गए features के साथ checkout करें।

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

Add Features Later

ग्राहक मौजूदा subscriptions में features जोड़ सकते हैं।

// 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!
  ]
});

हाइब्रिड Model 4: Seats + Usage

Per-user fee को consumption-based charges के साथ मिलाया जाता है। प्रत्येक user को एक allowance मिलता है।

Constraint: Dodo Payments वर्तमान में एक ही subscription product में usage meters और add-ons दोनों attach करने का समर्थन नहीं करता। इस model के लिए application-level logic का उपयोग करके workaround आवश्यक है।

यह कैसे काम करता है

Team Analytics: $20/user/month प्रत्येक user में शामिल:

5 GB data processing/month
Overage: allowance के बाद $2/GB

उदाहरण calculation (10-user team द्वारा कुल 80 GB का उपयोग):

Seat fees: 10 × $20 =$ 200.00
Included data: 10 × 5 GB = 50 GB
Overage: (80 - 50) × $2 =$ 60.00
कुल: $260.00/month

उपयोग के मामले

Analytics platforms: प्रति analyst + data processing
Design tools: प्रति designer + storage/exports
Development environments: प्रति developer + compute hours
Communication tools: प्रति user + message/call volume

Implementation विकल्प

चूँकि आप एक ही subscription में usage meters और add-ons दोनों संलग्न नहीं कर सकते, इनमें से कोई एक approach चुनें:

Option A: Usage Product + App-Managed Seats
Option B: Seat Add-on + On-Demand Usage Charges

Usage-based subscription का उपयोग करें और seat billing को अपने application में manage करें.

Create Usage Meter

Dashboard: Meters → Create Meter
Event Name: "data.processed"
Aggregation: Sum
Property: "bytes"

Create Usage-Based Subscription

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)

Manage Seats in Your Application

Seat count track करें और seat fees की अलग से calculation करें.

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

Calculate Dynamic Free Threshold

Seat count के आधार पर included usage adjust करें.

// 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 };
}

Seats के लिए add-ons का उपयोग करें और on-demand charges के माध्यम से usage का manual charge लें.

Create Seat Add-on

Dashboard: Products → Add-ons → Create Add-on
Name: "Team Member"
Price: $20/month

Create Subscription with Add-on

Dashboard: Create Product → Subscription
Name: "Team Analytics"
Base Price: $0/month

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

Enable on-demand charging

Track Usage in Your Application

// 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()
  });
}

Charge Usage at End of Cycle

Usage overages की manual calculation करें और charge लें.

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`
    });
  }
}

Recommendation: Option B (Seat Add-on + On-Demand Usage) को लागू करना अक्सर आसान होता है, क्योंकि Dodo seat billing को automatically manage करता है। आपको केवल usage overages track करके charge लेने हैं।

Hybrid Model 5: Subscription + Seats + Usage (Triple Hybrid)

सबसे व्यापक model: platform fee + प्रति user + consumption.

Constraint: Dodo Payments वर्तमान में एक ही subscription product में usage meters और add-ons दोनों संलग्न करने का समर्थन नहीं करता। इस model के लिए workaround approach आवश्यक है।

यह कैसे काम करता है

Enterprise Platform

Platform Fee: $199/month
Per Seat: $25/user/month
Usage: $0.10/1000 API calls (50K included)

उदाहरण calculation (20 users और 150,000 API calls वाली company):

Platform: $199.00
Seats: 20 × $25 =$ 500.00
Usage: (150K - 50K) × $0.10/1K = $10.00
कुल: $709.00/month

उपयोग के मामले

Enterprise SaaS: Platform + team + consumption
Data platforms: Workspace + analysts + queries
Integration platforms: Hub + connectors + transactions
AI platforms: Workspace + developers + inference

Implementation विकल्प

Triple hybrid billing लागू करने के लिए इनमें से कोई एक approach चुनें:

Option A: Base + Seats (Add-on) + On-Demand Usage
Option B: Base + Usage (Meter) + App-Managed Seats

Seat add-ons वाले subscription का उपयोग करें और on-demand charges के माध्यम से usage का manual charge लें.यह recommended approach है, क्योंकि Dodo platform fee और seat billing को automatically manage करता है।

Create Seat Add-on

Dashboard: Products → Add-ons → Create Add-on
Name: "User Seat"
Price: $25/month

Create Subscription Product

Dashboard: Create Product → Subscription
Name: "Enterprise Platform"
Base Price: $199/month

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

Enable on-demand charging

Create Checkout with Seats

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

Track Usage in Your Application

Usage events को अपने system में store करें.

// 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()
  });
}

Charge Usage at End of Cycle

On-demand charge के माध्यम से usage overages की calculation करें और charge लें.

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`
    });
  }
}

Usage meter वाले subscription का उपयोग करें और seat billing को अपने application में manage करें.

Create Usage Meter

Dashboard: Meters → Create Meter
Event Name: "api.call"
Aggregation: Count

Create Subscription Product with Usage

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

Manage Seats in Your Application

Seat count track करें और base subscription price को उसके अनुसार adjust करें.

// 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
}

Send Usage Events to Dodo

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()
    }]
  })
});

Recommendation: Option A (Base + Seats + On-Demand Usage) आम तौर पर आसान होता है, क्योंकि Dodo platform और seat billing को automatically manage करता है। आपको केवल usage track करके प्रत्येक billing cycle के अंत में charges submit करने होते हैं।

Hybrid Model 6: Tiered Base + Usage Overage

अलग-अलग subscription tiers में अलग included allowances और overage rates होते हैं।

यह कैसे काम करता है

Tier	Price	Included Calls	Overage Rate
Starter	$19/month	1,000	$0.02/call
Pro	$79/month	25,000	$0.01/call
Business	$199/month	100,000	$0.005/call
Enterprise	$499/month	500,000	$0.002/call

Implementation

प्रत्येक tier के लिए अलग subscription products बनाएँ और हर product में अपना usage configuration रखें:

# 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

Upgrade Path

जब customers tiers upgrade करते हैं, तो उन्हें मिलता है:

अधिक included allowance
कम overage rates
प्रति dollar अधिक value

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

Hybrid Model 7: Subscription + On-Demand Charges

Recurring subscription के साथ services या overages के लिए variable manual charges।

यह कैसे काम करता है

Retainer Plan: $199/month इसमें शामिल:

Platform access
5 hours consulting/month
Email support

On-Demand Charges (आवश्यकतानुसार):

Extra consulting: $150/hour
Custom development: $200/hour
Emergency support: $100/incident

उदाहरण calculation (इस महीने):

Retainer: $199.00
3 extra consulting hours: $450.00
1 emergency support: $100.00
कुल: $749.00

उपयोग के मामले

Consulting services: Retainer + hourly billing
Managed services: Base fee + incident charges
Agency services: Monthly fee + project charges
Support plans: SLA fee + per-ticket या per-hour

Implementation

Create On-Demand Subscription

On-demand charging enabled करके subscription set up करें.

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
  }
});

Charge for Services

Services deliver होने पर charges create करें.

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

Track and Invoice

सभी charges customer के invoice पर दिखाई देते हैं.

// 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.payment_id}: $${payment.total_amount / 100}`);
});

वास्तविक उदाहरण

ये उदाहरण आदर्श pricing structures दिखाते हैं। Usage meters और add-ons को एक ही product में संलग्न नहीं किया जा सकता, इसलिए कुछ combinations के लिए workarounds आवश्यक हैं (usage के लिए on-demand charges या app-managed seats का उपयोग करके)।

उदाहरण 1: AI SaaS Platform

Pricing Structure:

Base Subscription: $99/month (platform access, 5 seats included)
Seat Add-on: $20/seat/month
Feature Add-ons: Custom Models ($49/mo), API Access ($29/mo), Priority Queue ($19/mo)
Usage Overage: 100K के बाद $0.02 प्रति 1,000 tokens (on-demand के माध्यम से charge किया गया)

Implementation: Seat और feature add-ons वाले subscription का उपयोग करें। अपने application में token usage track करें और billing cycle के अंत में on-demand charges के माध्यम से overages charge करें. उदाहरण customer (12 users, 500K tokens, Custom Models + API Access):

Component	Calculation	Amount
Base	Platform fee	$99
Extra seats	7 × $20	$140
Custom Models	Add-on	$49
API Access	Add-on	$29
Token overage	400K × $0.02/1K (on-demand)	$8
कुल		$325/month

उदाहरण 2: Developer Tools Platform

Tier Options:

	Free	Pro	Enterprise
Price	$0/month	$29/month	$199/month
Users	1	5 included	Unlimited
Builds	100	1,000	10,000
Storage	1 GB	10 GB	100 GB

Implementation Options: Option A (Usage-focused): Builds/storage के लिए usage meters वाले products बनाएँ। Users को अपने application में manage करें. Option B (Seat-focused): Seat add-ons वाले products बनाएँ। Builds/storage usage track करें और on-demand के माध्यम से overages charge करें. Add-ons (यदि Option B का उपयोग कर रहे हैं):

Extra users: $10/user/month
Priority builds: $19/month
Custom domains: $9/domain/month

उदाहरण 3: Marketing Automation

Pricing Structure:

Base: $79/month (core automation features, 3 seats included)
Contact Tiers (add-ons): 1K included, 5K (+$30), 25K (+$80), 100K (+$200)
Feature Add-ons: SMS Marketing ($29/mo), Landing Pages ($19/mo), A/B Testing ($29/mo)
Team Seats: $15/user/month add-on
Email Volume: Application में track करें और on-demand के माध्यम से overage charge करें (limit से अधिक $1/1,000 emails)

Implementation: Contact tier add-ons, feature add-ons और seat add-ons वाले subscription का उपयोग करें। अपने application में email sends track करें और on-demand charges के माध्यम से overages charge करें.

Implementation की सर्वोत्तम practices

Pricing Page की स्पष्टता

Hybrid pricing को समझना आसान बनाएँ। अपने pricing page पर base costs, क्या शामिल है और overages कैसे काम करते हैं, इसे प्रमुखता से दिखाएँ।

अच्छा: “$49/month में 10,000 API calls शामिल हैं। Additional calls: $0.005 each” खराब: “$49/month + usage fees”

Cost Predictability

Customers को अपनी costs का अनुमान लगाने में सहायता करें:

// 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;
}

Usage Visibility

Customers को real-time में उनका usage दिखाएँ:

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

Billing Transparency

सभी components दिखाने वाले detailed invoices प्रदान करें:

Line Item	Amount
Pro Plan (Monthly)	$49.00
Additional Seats (7 × $15.00)	$105.00
API Usage - Included (10,000 calls)	$0.00
API Usage - Overage (15,420 calls × $0.005)	$77.10
Advanced Analytics Add-on	$19.00
Subtotal	$250.10
Tax (8.5%)	$21.26
Total Due	$271.36

Hybrid Billing की troubleshooting

Usage not being tracked correctly

Symptoms: Usage 0 या गलत values दिखाता है.Solutions:

Verify करें कि event ingestion काम कर रहा है (API responses check करें)
Confirm करें कि customer_id subscription customer से match करता है
Check करें कि event_name meter configuration से match करता है
Verify करें कि events में सही timestamps हैं (future-dated नहीं)

Proration confusion with multiple components

Symptoms: Plans बदलने पर customer से अप्रत्याशित amounts charge किए गए.Solutions:

Confirm करने से पहले exact charges दिखाने के लिए previewChangePlan API का उपयोग करें
Communicate करें कि proration subscription और add-ons दोनों पर लागू होता है
सरल upgrade billing के लिए difference_immediately का उपयोग करने पर विचार करें

Free threshold not applying correctly

Symptoms: Customer से उस usage के लिए charge लिया गया जो free होना चाहिए था.Solutions:

Verify करें कि usage-based product पर free threshold configured है
Check करें कि threshold unit event aggregation से match करता है (calls बनाम requests)
Confirm करें कि usage meter subscription product से सही तरीके से attached है

Add-ons not appearing in checkout

Symptoms: Checkout के दौरान seats या features add नहीं कर सकते.Solutions:

Verify करें कि dashboard में add-ons subscription product से attached हैं
Check करें कि API calls में add-on IDs सही हैं
Ensure करें कि add-on currency subscription product की currency से match करती है

Products

सभी product types और guides का overview।

Usage-Based Billing Guide

Complete usage billing implementation।

Subscription Management

Recurring subscriptions को manage करना।

Add-ons

Add-ons के साथ subscriptions को extend करना।

अंतिम संशोधन 6 अगस्त 2026

Usage-Based Billing

Subscriptions

Add-ons

Seat-Based Billing

​हाइब्रिड Billing क्या है?

​हाइब्रिड Billing का उपयोग क्यों करें?

​सामान्य हाइब्रिड Patterns

​हाइब्रिड Model 1: Subscription + Usage

​यह कैसे काम करता है

​Use Cases

​Implementation

​Pricing Variations

​हाइब्रिड Model 2: Subscription + Seats

​यह कैसे काम करता है

​Use Cases

​Implementation

​Pricing Variations

​हाइब्रिड Model 3: Subscription + Feature Add-ons

​यह कैसे काम करता है

​Use Cases

​Implementation

​हाइब्रिड Model 4: Seats + Usage

​यह कैसे काम करता है

​उपयोग के मामले

​Implementation विकल्प

​Hybrid Model 5: Subscription + Seats + Usage (Triple Hybrid)

​यह कैसे काम करता है

​उपयोग के मामले

​Implementation विकल्प

​Hybrid Model 6: Tiered Base + Usage Overage

​यह कैसे काम करता है

​Implementation

​Upgrade Path

​Hybrid Model 7: Subscription + On-Demand Charges

​यह कैसे काम करता है

​उपयोग के मामले

​Implementation

​वास्तविक उदाहरण

​उदाहरण 1: AI SaaS Platform

​उदाहरण 2: Developer Tools Platform

​उदाहरण 3: Marketing Automation

​Implementation की सर्वोत्तम practices

​Pricing Page की स्पष्टता

​Cost Predictability

​Usage Visibility

​Billing Transparency

​Hybrid Billing की troubleshooting

​संबंधित documentation

Products

Usage-Based Billing Guide

Subscription Management

Add-ons

हाइब्रिड Billing क्या है?

हाइब्रिड Billing का उपयोग क्यों करें?

सामान्य हाइब्रिड Patterns

हाइब्रिड Model 1: Subscription + Usage

यह कैसे काम करता है

Use Cases

Implementation

Pricing Variations

हाइब्रिड Model 2: Subscription + Seats

यह कैसे काम करता है

Use Cases

Implementation

Pricing Variations

हाइब्रिड Model 3: Subscription + Feature Add-ons

यह कैसे काम करता है

Use Cases

Implementation

हाइब्रिड Model 4: Seats + Usage

यह कैसे काम करता है

उपयोग के मामले

Implementation विकल्प

Hybrid Model 5: Subscription + Seats + Usage (Triple Hybrid)

यह कैसे काम करता है

उपयोग के मामले

Implementation विकल्प

Hybrid Model 6: Tiered Base + Usage Overage

यह कैसे काम करता है

Implementation

Upgrade Path

Hybrid Model 7: Subscription + On-Demand Charges

यह कैसे काम करता है

उपयोग के मामले

Implementation

वास्तविक उदाहरण

उदाहरण 1: AI SaaS Platform

उदाहरण 2: Developer Tools Platform

उदाहरण 3: Marketing Automation

Implementation की सर्वोत्तम practices

Pricing Page की स्पष्टता

Cost Predictability

Usage Visibility

Billing Transparency

Hybrid Billing की troubleshooting

संबंधित documentation