Build package pricing finance and customers both trust
Your customers buy usage in whole blocks at a fixed price. They know exactly what they’re paying. Finance knows what’s coming. Chargebee handles rounding and invoicing automatically. No micro-charges, no per-unit disputes, just a straightforward monthly cadence customers understand immediately.
Package pricing: predictable pricing, simple billing, dispute-free revenue
Customers buy capacity in whole blocks (or packages, the terms are used interchangeably), not individual units. Your API reports raw counts; Chargebee accumulates across the period and rounds up at close. Every unit of consumption maps to a fixed-price block. The key difference from per-unit metering: customers always pay for complete blocks, never fractional costs.
Compare this to per-unit metering, where charges scale with decimals. A customer consuming 1.2 million characters at $0.0000275 per character pays $33.00. With package pricing, that same usage rounds to 2 blocks at $27.50 each = $55.00. You trade a slightly higher per-unit cost for revenue predictability. Customers know their costs upfront, reducing billing confusion and churn.
- You sell digital products where value is measured in discrete units: characters, tokens, API calls, documents, or similar
- A full block costs little enough that low-volume customers don't push back on paying for the headroom
- You want to reduce billing complexity and customer disputes about fractional charges
- Your customer base values predictable, auditable invoices over minimal per-unit cost
Here's what you need
Three objects in the Chargebee catalog. Set them up once and package pricing is live. There is nothing else to wire up, which is what keeps this model simple to run.
Required on every Chargebee subscription. Here it carries the flat $1,500/mo platform fee, keeping the fixed base charge cleanly separated from variable usage.
A metered add-on where DeepL defines the package: 1,000,000 characters per block at $27.50. This is the protagonist of the recipe.
Add a feature called translation_quota to each plan and set a different included limit for each one. Your app checks this value to see how many translations are included. Customers are only charged through the metered add-on after they exceed that limit.
Define the block size and price once.
Every subscription inherits it
Package pricing is built on three components working together. A plan anchors the subscription with the flat platform fee. A metered add-on tracks character usage and applies package pricing, rounding consumption to the nearest 1M-character block. A feature entitlement sets per-plan included quotas so charges only fire after customers exceed their limit. Here's how to configure each.
The metered add-on is where DeepL defines the package, 1,000,000 characters at $27.50 per block. Raw character counts flow in from DeepL's app, Chargebee accumulates them across the period, and the invoice shows a single rounded line at close.
| Setting | Value | Notes |
|---|---|---|
| Item type | Metered | Usage reported via API each billing period |
| Pricing model | Volume | Required for package pricing. Tiered also works. |
| Price per unit | $0.000025 | Per character - Chargebee multiplies by package size internally |
| Advanced pricing config | Enabled | Unlocks the package size field |
| Package size | 1,000,000 | Chargebee bills ⌈usage ÷ 1,000,000⌉ packages at $27.50 each |
| Plan | Feature | Type | Entitlement level |
|---|---|---|---|
| Starter translation-api-starter | translation_quota | Quantity | 5,000,000chars |
| Growth translation-api-growth | translation_quota | Quantity | 50,000,000chars |
| Enterprise translation-api-enterprise | translation_quota | Quantity | Unlimited |
subscription_id to get the customer’s translation_quota level. Characters consumed below that level are covered by the plan. Usage above it is reported to the chars_translated metered add-on and billed as packages. Customers know exactly what they’re buying before they sign
The quote is transparent: a flat platform fee plus a per-block rate. There are no hidden tiers, no volume discounts waiting to be negotiated, no usage thresholds that shift pricing. The customer sees the formula at signing and knows it won't change. On acceptance, Chargebee activates the subscription and begins tracking usage from the start date.
| Line item | Type | Unit | Monthly amount |
|---|---|---|---|
| Translation API – Platform fee Flat monthly access fee | Flat | 1 × 1 mo | $1,500 |
| chars_translated Metered · billed monthly in 1M-char packages · ceil rounding | Metered (pkg) | $27.50 / 1M chars | Per usage |
Report raw counts. Chargebee handles the package math
Each batch fires a usage event with four fields: subscription_id, item_price_id, quantity (raw char count), and a deduplication_id. Report at any granularity, per call, hourly batch, or daily rollup. Chargebee accumulates everything and applies ⌈total ÷ 1,000,000⌉ once, at period close.
| Event ID | Timestamp | Chars reported | Running total |
|---|---|---|---|
| evt_9204 | Jun 28, 14:11 | 48,000,000 | 400,000,000 |
| evt_9203 | Jun 27, 09:44 | 62,000,000 | 352,000,000 |
| evt_9202 | Jun 25, 16:30 | 90,000,000 | 290,000,000 |
| evt_9201 | Jun 22, 11:07 | 200,000,000 | 200,000,000 |
// Fire after each translation batch { "subscription_id": "SUB-2026-DPL-001", "item_price_id": "chars_translated-USD-monthly", "usage_date": 1751132400, "quantity": "480000", "deduplication_id": "evt_9204" } // Report raw chars - not packages. // Chargebee rounds at period close, // not at the time of this event.
⌈ 400,000,000 ÷ 1,000,000 ⌉ = 400 packages
invoice = 400 × $27.50 = $11,000.00
Customers see their charges accumulating, in real time
Pull past invoices from Chargebee's API and surface monthly spend, packages billed, and usage trend. Customers see costs building in real time instead of getting surprised at invoice close.
What DeepL pulls from the API:
- Month-on-month invoice amount, from the amount_paid field on each past invoice
- Packages billed per period, from the metered line item's quantity field
- Usage trend over the last 12 months, by comparing invoice amounts period-over-period
// Query params subscription_id=AzBc-DeepL-001 limit=12 sort_by[desc]=date // Response, each past invoice { "list": [ { "invoice": { "id": "INV-2026-0405", "date": 1717113600, "amount_paid": 700000, "line_items": [ { "entity_id": "Translation-Platform-Fee", "quantity": 1, "amount": 150000 }, { "entity_id": "chars_translated", "quantity": 200, "amount": 550000 } ] }}, // ... 11 more invoices ] }
Period closes. Chargebee rounds, invoices, collects. No manual work
At month-end, Chargebee applies the rounding formula to the accumulated usage, generates the invoice, and charges the customer's card on file. The invoice line items match the quote the customer signed. DeepL's finance team does no rounding calculations, no tier lookups, no manual adjustments. Chargebee handles it all.
| Description | Qty | Unit price | Amount |
|---|---|---|---|
| Translation API – Platform fee Jun 1–30, 2026 | 1 | $1,500.00 | $1,500.00 |
| chars_translated - 400 packages 400,000,000 chars → ⌈400⌉ = 400 packages × $27.50 | 400 pkg | $27.50 | $11,000.00 |
Simplicity that customers understand immediately.
Package pricing removes micro-charges and disputes because customers know exactly what they’re paying. Chargebee rounds usage to whole blocks automatically, invoices without spreadsheets, and handles mid-cycle upgrades in the billing workflow. Finance gets predictable revenue. RevOps sees when customers run out of capacity and are ready to buy more.