Modeller för hybrid fakturering - Dodo Payments Documentation

Hybrid fakturering kombinerar två eller fler faktureringsmodeller till en enda prisstrategi. Det gör att du kan fånga värde från olika dimensioner – återkommande avgifter, användning, platser och funktioner – samtidigt som kunderna får flexibilitet och förutsägbarhet.

Usage-Based Billing

Grund för användningsbaserad prissättning.

Subscriptions

Grund för återkommande fakturering.

Add-ons

Utöka prenumerationer med valfria uppgraderingar.

Seat-Based Billing

Prissättningsmodeller per användare.

Vad är hybrid fakturering?

Hybrid fakturering kombinerar flera prisdimensioner i ett enda produkterbjudande. I stället för att välja mellan prenumeration med fast pris ELLER användningsbaserad prissättning använder du båda tillsammans.

Varför använda hybrid fakturering?

Affärsmål	Hybridlösning
Förutsägbara intäkter + tillväxtpotential	Basprenumeration + överskridande av användning
Teamprissättning som kan skalas	Per plats + funktionstillägg
Vinn kunder, utöka senare	Låg basavgift + förbrukningsavgifter
Flexibilitet för företag	Avtalad spend + avgifter på begäran
Rättvis prissättning vid varierande användning	Inkluderad kvot + betala per användning

Vanliga hybridmönster

Modell	Beskrivning	Exempel	Inbyggt stöd
1. Prenumeration + användning	Basavgift + förbrukningsavgifter	$49/mån + $0.01/API-anrop efter 10K gratis	✅ Fullständigt
2. Prenumeration + platser	Plattformavgift + avgifter per användare	$99/mån + $15/plats	✅ Fullständigt
3. Prenumeration + funktionstillägg	Grundplan + valfria uppgraderingar	$29/mån + $19/mån analys + $9/mån API-åtkomst	✅ Fullständigt
4. Platser + användning	Avgift per användare + förbrukningsöverskridande	$10/användare/mån + $0.05/GB efter 5 GB/användare	⚠️ Lösning krävs
5. Prenumeration + platser + användning	Plattform + användare + förbrukning (trippelhybrid)	$199/mån + $20/plats + överskridande användning	⚠️ Lösning krävs
6. Nivåindelad bas + överskridande användning	Olika nivåer med olika kvoter	Starter (5K anrop) kontra Pro (50K anrop) + överskridande	✅ Fullständigt
7. Prenumeration + avgifter på begäran	Återkommande avgift + varierande manuella avgifter	$99/mån retainer + timdebitering för arbete	✅ Fullständigt

Hybridmodell 1: Prenumeration + användning

Den vanligaste hybridmodellen. Kunder betalar en basavgift för prenumerationen samt avgifter för förbrukning som överstiger de inkluderade kvoterna.

Så fungerar det

Pro-plan: $49/månad

Inkluderat: 10 000 API-anrop/månad
Överskridande: $0.005 per anrop efter 10 000

Exempelberäkning (kunden använder 25 000 anrop den här månaden):

Basprenumeration: $49.00
Överskridande: (25 000 - 10 000) × $0.005 =$ 75.00
Totalt: $124.00

Användningsområden

API-plattformar: Basåtkomst + avgifter per begäran
AI/ML-tjänster: Prenumeration + användning av token/generering
Lagringstjänster: Basplan + överskridande per GB
Kommunikationsplattformar: Bas + avgifter per meddelande/minut

Implementering

Create Usage Meter

Konfigurera en mätare för att spåra den debiterbara användningsdimensionen.

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

Create Subscription Product with Usage Pricing

Skapa en prenumerationsprodukt och koppla användningsmätaren med prissättning.

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)

Användningsmätaren kopplas direkt till prenumerationsprodukten. Användningsavgifter beräknas och läggs automatiskt till på prenumerationsfakturan.

Create Checkout Session

Skapa en checkout-session med din prenumerationsprodukt.

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

Spåra användningen under hela faktureringsperioden.

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

Prisvariationer

Included Allowance
Zero Base + Pure Usage
Tiered Allowances

Den kostnadsfria tröskeln täcker användning som ingår i basprenumerationen.Pro-plan: $49/månad

Inkluderar: 10 000 API-anrop
Överskridande: $0.005/anrop efter 10 000
Kunden använder 8 000 → Betalar $49 (inget överskridande)

Hybrid Model 2: Subscription + Seats

Platform fee plus per-user charges. Ideal for team collaboration tools and B2B SaaS.

How It Works

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

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

Example calculation (team of 12 users):

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

Create an add-on for additional seats.

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

Create Base Subscription

Create the subscription product with platform fee and attach the add-on.

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

Specify seat quantity during checkout.

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

Add or remove seats on existing subscriptions.

// 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 includes some seats, charge for extras.Team Plan: $99/month

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

Hybrid Model 3: Subscription + Feature Add-ons

Core subscription with optional feature upgrades customers can add.

How It Works

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 (customer chooses 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

Create an add-on for each optional feature.

# 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

Define your base subscription and attach all feature add-ons.

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

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

Let Customers Choose

Checkout with selected features.

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

Customers can add features to existing subscriptions.

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

Hybrid Model 4: Seats + Usage

Per-user fee combined with consumption-based charges. Each user gets an allowance.

Constraint: Dodo Payments does not currently support attaching both usage meters and add-ons to the same subscription product. This model requires a workaround using application-level logic.

Så fungerar det

Team Analytics: 20 $/användare/månad Varje användare inkluderar:

5 GB databehandling/månad
Överstigande användning: 2 $/GB efter inkluderad mängd

Exempelberäkning (team med 10 användare som använder totalt 80 GB):

Platsavgifter: 10 × 20 $= 200,00$
Inkluderad data: 10 × 5 GB = 50 GB
Överstigande användning: (80 - 50) × 2 $= 60,00$
Totalt: 260,00 $/månad

Användningsområden

Analytics-plattformar: Per analytiker + databehandling
Designverktyg: Per designer + lagring/exporter
Utvecklingsmiljöer: Per utvecklare + beräkningstimmar
Kommunikationsverktyg: Per användare + meddelande-/samtalsvolym

Implementeringsalternativ

Eftersom du inte kan koppla både usage meters och add-ons till samma subscription väljer du ett av följande tillvägagångssätt:

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

Använd en usage-based subscription och hantera platsdebiteringen i din applikation.

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

Spåra antalet platser och beräkna platsavgifterna separat.

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

Justera inkluderad användning baserat på antalet platser.

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

Använd add-ons för platser och debitera användningen manuellt via on-demand charges.

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

Beräkna och debitera överstigande användning manuellt.

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

Rekommendation: Alternativ B (Seat Add-on + On-Demand Usage) är ofta enklare att implementera eftersom Dodo hanterar platsdebiteringen automatiskt. Du behöver bara spåra och debitera överstigande användning.

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

Den mest omfattande modellen: plattformsavgift + per användare + förbrukning.

Begränsning: Dodo Payments har för närvarande inte stöd för att koppla både usage meters och add-ons till samma subscription product. Den här modellen kräver en workaround.

Så fungerar det

Enterprise Platform

Plattformsavgift: 199 $/månad
Per plats: 25 $/användare/månad
Användning: 0,10 $/1 000 API-anrop (50 000 inkluderade)

Exempelberäkning (företag med 20 användare och 150 000 API-anrop):

Plattform: 199,00 $
Platser: 20 × 25 $= 500,00$
Användning: (150K - 50K) × $0.10/1K = $10.00
Totalt: 709,00 $/månad

Användningsområden

Enterprise SaaS: Plattform + team + förbrukning
Dataplattformar: Arbetsyta + analytiker + frågor
Integrationsplattformar: Hubb + anslutningar + transaktioner
AI-plattformar: Arbetsyta + utvecklare + inferens

Implementeringsalternativ

Välj ett av följande tillvägagångssätt för att implementera triple hybrid billing:

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

Använd subscription med seat add-ons och debitera användningen manuellt via on-demand charges.Det här är det rekommenderade tillvägagångssättet eftersom Dodo hanterar plattformsavgiften och platsdebiteringen automatiskt.

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

Lagra användningshändelser i ditt system.

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

Beräkna och debitera överstigande användning via on-demand 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`
    });
  }
}

Använd subscription med usage meter och hantera platsdebiteringen i din applikation.

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

Spåra antalet platser och justera baspriset för subscription i enlighet med detta.

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

Rekommendation: Alternativ A (Base + Seats + On-Demand Usage) är generellt enklare eftersom Dodo hanterar plattforms- och platsdebiteringen automatiskt. Du behöver bara spåra användningen och skicka in charges i slutet av varje faktureringsperiod.

Hybridmodell 6: Tiered Base + Usage Overage

Olika subscription tiers med olika inkluderade mängder och priser för överstigande användning.

Så fungerar det

Tier	Pris	Inkluderade anrop	Pris för överstigande användning
Starter	19 $/månad	1 000	0,02 $/anrop
Pro	79 $/månad	25 000	0,01 $/anrop
Business	199 $/månad	100 000	0,005 $/anrop
Enterprise	499 $/månad	500 000	0,002 $/anrop

Implementering

Skapa separata subscription products för varje tier, där varje produkt har sin egen 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

Uppgraderingsväg

När kunder uppgraderar tier får de:

Högre inkluderad mängd
Lägre priser för överstigande användning
Mer värde per krona

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

Hybridmodell 7: Subscription + On-Demand Charges

Återkommande subscription plus varierande manuella charges för tjänster eller överstigande användning.

Så fungerar det

Retainer Plan: 199 $/månad Inkluderar:

Plattformsåtkomst
5 konsulttimmar/månad
E-postsupport

On-Demand Charges (vid behov):

Extra konsultation: 150 $/timme
Anpassad utveckling: 200 $/timme
Akutsupport: 100 $/incident

Exempelberäkning (den här månaden):

Retainer: 199,00 $
3 extra konsulttimmar: 450,00 $
1 akutsupport: 100,00 $
Totalt: 749,00 $

Användningsområden

Konsulttjänster: Retainer + timdebitering
Managed services: Basavgift + incidentavgifter
Byråtjänster: Månadsavgift + projektavgifter
Supportplaner: SLA-avgift + per ärende eller timme

Implementering

Create On-Demand Subscription

Konfigurera en subscription med on-demand charging aktiverat.

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

Skapa charges när tjänsterna levereras.

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

Alla charges visas på kundens 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}`);
});

Verkliga exempel

De här exemplen visar ideala prisstrukturer. Eftersom usage meters och add-ons inte kan kopplas till samma product kräver vissa kombinationer workarounds (on-demand charges för användning eller apphanterade platser).

Exempel 1: AI SaaS Platform

Prisstruktur:

Base Subscription: 99 $/månad (plattformsåtkomst, 5 platser inkluderade)
Seat Add-on: 20 $/plats/månad
Feature Add-ons: Custom Models ($49/mo), API Access ($29/mo), Priority Queue ($19/mo)
Usage Overage: 0,02 $ per 1 000 tokens efter 100K (debiteras via on-demand)

Implementering: Använd subscription med seat- och feature add-ons. Spåra tokenanvändningen i din applikation och debitera överstigande användning via on-demand charges i slutet av faktureringsperioden. Exempelkund (12 användare, 500K tokens, Custom Models + API Access):

Komponent	Beräkning	Belopp
Base	Plattformsavgift	$99
Extra platser	7 × $20	$140
Custom Models	Add-on	$49
API Access	Add-on	$29
Token overage	400K × $0.02/1K (on-demand)	$8
Totalt		$325/månad

Exempel 2: Developer Tools Platform

Tier-alternativ:

	Free	Pro	Enterprise
Pris	$0/månad	$29/månad	$199/månad
Användare	1	5 inkluderade	Obegränsat
Builds	100	1 000	10 000
Lagring	1 GB	10 GB	100 GB

Implementeringsalternativ: Alternativ A (användningsfokuserat): Skapa products med usage meters för builds/lagring. Hantera användare i din applikation. Alternativ B (platsfokuserat): Skapa products med seat add-ons. Spåra builds-/lagringsanvändning och debitera överstigande användning via on-demand. Add-ons (om du använder alternativ B):

Extra användare: 10 $/användare/månad
Prioriterade builds: 19 $/månad
Anpassade domäner: 9 $/domän/månad

Exempel 3: Marketing Automation

Prisstruktur:

Base: 79 $/månad (centrala automatiseringsfunktioner, 3 platser inkluderade)
Contact Tiers (add-ons): 1K inkluderade, 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 $/användare/månad som add-on
E-postvolym: Spåra i applikationen och debitera överstigande användning via on-demand (1 $/1 000 e-postmeddelanden över gränsen)

Implementering: Använd subscription med contact tier add-ons, feature add-ons och seat add-ons. Spåra skickade e-postmeddelanden i din applikation och debitera överstigande användning via on-demand charges.

Bästa praxis för implementering

Tydlighet på prissidan

Gör hybridprissättning lätt att förstå. Visa baskostnader, vad som ingår och hur överstigande användning fungerar tydligt på prissidan.

Bra: “$49/månad inkluderar 10 000 API-anrop. Ytterligare anrop: $0.005 styck” Dåligt: “$49/månad + användningsavgifter”

Förutsägbara kostnader

Hjälp kunderna att uppskatta sina kostnader:

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

Synlighet för användning

Visa kunderna deras användning i realtid:

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

Transparent debitering

Tillhandahåll detaljerade invoices som visar alla komponenter:

Radpost	Belopp
Pro Plan (månadsvis)	$49.00
Ytterligare platser (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
Delsumma	$250.10
Skatt (8.5%)	$21.26
Totalt att betala	$271.36

Felsökning av hybriddebitering

Usage not being tracked correctly

Symptom: Användningen visas som 0 eller med felaktiga värden.Lösningar:

Kontrollera att event ingestion fungerar (kontrollera API-svar)
Bekräfta att customer_id matchar subscription-kunden
Kontrollera att event_name matchar meter-konfigurationen
Kontrollera att events har korrekta tidsstämplar (inte framtidsdaterade)

Proration confusion with multiple components

Symptom: Kunden debiteras oväntade belopp när planer ändras.Lösningar:

Använd previewChangePlan API för att visa exakta charges innan du bekräftar
Informera om att proratering gäller för subscription OCH add-ons
Överväg att använda difference_immediately för enklare uppgraderingsdebitering

Free threshold not applying correctly

Symptom: Kunden debiteras för användning som borde vara kostnadsfri.Lösningar:

Kontrollera att den kostnadsfria gränsen är konfigurerad på den usage-based produkten
Kontrollera att gränsenheten matchar händelseaggregeringen (anrop kontra requests)
Bekräfta att usage meter är korrekt kopplad till subscription product

Add-ons not appearing in checkout

Symptom: Det går inte att lägga till platser eller funktioner under checkout.Lösningar:

Kontrollera att add-ons är kopplade till subscription product i dashboard
Kontrollera att add-on IDs är korrekta i API-anrop
Säkerställ att add-on-valutan matchar subscription product-valutan

Relaterad dokumentation

Products

Översikt över alla produkttyper och guider.

Usage-Based Billing Guide

Fullständig implementering av usage billing.

Subscription Management

Hantering av återkommande subscriptions.

Add-ons

Utöka subscriptions med add-ons.

Usage-Based Billing

Subscriptions

Add-ons

Seat-Based Billing

​Vad är hybrid fakturering?

​Varför använda hybrid fakturering?

​Vanliga hybridmönster

​Hybridmodell 1: Prenumeration + användning

​Så fungerar det

​Användningsområden

​Implementering

​Prisvariationer

​Hybrid Model 2: Subscription + Seats

​How It Works

​Use Cases

​Implementation

​Pricing Variations

​Hybrid Model 3: Subscription + Feature Add-ons

​How It Works

​Use Cases

​Implementation

​Hybrid Model 4: Seats + Usage

​Så fungerar det

​Användningsområden

​Implementeringsalternativ

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

​Så fungerar det

​Användningsområden

​Implementeringsalternativ

​Hybridmodell 6: Tiered Base + Usage Overage

​Så fungerar det

​Implementering

​Uppgraderingsväg

​Hybridmodell 7: Subscription + On-Demand Charges

​Så fungerar det

​Användningsområden

​Implementering

​Verkliga exempel

​Exempel 1: AI SaaS Platform

​Exempel 2: Developer Tools Platform

​Exempel 3: Marketing Automation

​Bästa praxis för implementering

​Tydlighet på prissidan

​Förutsägbara kostnader

​Synlighet för användning

​Transparent debitering

​Felsökning av hybriddebitering

​Relaterad dokumentation

Products

Usage-Based Billing Guide

Subscription Management

Add-ons

Vad är hybrid fakturering?

Varför använda hybrid fakturering?

Vanliga hybridmönster

Hybridmodell 1: Prenumeration + användning

Så fungerar det

Användningsområden

Implementering

Prisvariationer

Hybrid Model 2: Subscription + Seats

How It Works

Use Cases

Implementation

Pricing Variations

Hybrid Model 3: Subscription + Feature Add-ons

How It Works

Use Cases

Implementation

Hybrid Model 4: Seats + Usage

Så fungerar det

Användningsområden

Implementeringsalternativ

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

Så fungerar det

Användningsområden

Implementeringsalternativ

Hybridmodell 6: Tiered Base + Usage Overage

Så fungerar det

Implementering

Uppgraderingsväg

Hybridmodell 7: Subscription + On-Demand Charges

Så fungerar det

Användningsområden

Implementering

Verkliga exempel

Exempel 1: AI SaaS Platform

Exempel 2: Developer Tools Platform

Exempel 3: Marketing Automation

Bästa praxis för implementering

Tydlighet på prissidan

Förutsägbara kostnader

Synlighet för användning

Transparent debitering

Felsökning av hybriddebitering

Relaterad dokumentation