> ## 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.
# ElevenLabs Billing Model
> Deconstruct ElevenLabs' character-based billing with rollover credits and tiered overage pricing, then build the same model using Dodo Payments.
ElevenLabs bills its AI voice products from a single pool of credits tied to the subscription tier. For text-to-speech, one character costs about one credit, so the character is the unit most users track. Text-to-speech, voice cloning, and dubbing all draw from the same pool.
## How ElevenLabs Bills
ElevenLabs sells fixed monthly quotas through subscription tiers. Higher tiers include more characters and more advanced features, such as Professional Voice Cloning and commercial rights.
| Plan | Price | Credits/Month |
| :- | :- | :- |
| Free | \$0 | 10,000 |
| Starter | \$6/month | 30,000 |
| Creator | \$22/month | 121,000 |
| Pro | \$99/month | 600,000 |
| Scale | \$299/month | 1,800,000 |
| Business | \$990/month | 6,000,000 |
1. **Character-based pricing**: Characters, counted as credits, are the shared unit across the platform. Text-to-speech, dubbing, and voice cloning all draw from the same balance, so users track one number.
2. **Rollover mechanics**: Unused credits roll over to the next billing cycle instead of expiring. ElevenLabs caps rollover at two months of unused quota, so a balance can reach at most three times the monthly quota. Rollover requires an active paid plan and doesn't apply to the Free plan ([ElevenLabs pricing FAQ](https://elevenlabs.io/pricing)).
3. **Tiered overages**: Overage depends on the subscription tier. Enterprise and legacy Creator, Pro, Scale, and Business plans can opt in to usage-based billing, which charges a plan-specific price for each extra 1,000 credits. New self-serve subscriptions use Pay As You Go top-up credits instead ([ElevenLabs billing docs](https://elevenlabs.io/docs/overview/administration/billing)).
## What Makes It Unique
Four choices make the ElevenLabs model good at retaining users and driving upgrades:
* **Character Rollover**: Rollover reduces "use it or lose it" anxiety. A quiet month doesn't waste the subscription.
* **Tiered Overage Pricing**: Overage rates fall as plan size grows, so heavy users have a strong financial reason to upgrade.
* **Unified Consumption**: One pool for all services means users don't juggle separate quotas.
* **Opt-in Overages**: Professional users can turn on overage for continuity, and casual users keep the safety of a hard cap.
The diagram shows one billing cycle, from fresh credits to rollover:
```mermaid theme={null}
flowchart TD
A[New Billing Cycle] --> B[Fresh Credits + Rolled Over]
B --> C[User Generates Audio]
C --> D{Characters Left?}
D -->|Yes| C
D -->|No| E{Overage Enabled?}
E -->|Yes| F[Bill at Tier Rate]
F --> C
E -->|No| G[Generation Blocked]
D -->|Cycle Ends| H[Unused Credits Roll Over]
H --> A
```
## Build This with Dodo Payments
You can build this model with Dodo Payments credit-based billing and usage metering.
Define the "Characters" unit that serves as your platform's currency.
1. Go to **Products → Credits** in your Dodo Payments dashboard.
2. Click **Create Credit**.
3. Set **Credit Type** to **Custom Unit**.
4. Set **Unit Name** to "Characters".
5. Set **Precision** to 0, because characters are whole units.
6. Set **Credit Expiry** to 30 days to match the monthly billing cycle.
7. Enable **Rollover** with these settings:
* **Max Rollover Percentage**: 100% (all unused characters carry over).
* **Rollover Timeframe**: 1 Month.
* **Max Rollover Count**: 2 (credits can roll over twice, matching ElevenLabs' two-month cap, then they're forfeited).
Create five subscription products. Attach the same "Characters" credit to each, with a different configuration per tier.
| Product | Price | Credits/Cycle | Overage Enabled | Overage Price (per 1K chars) |
| :- | :- | :- | :- | :- |
| Free | \$0/mo | 10,000 | No | - |
| Starter | \$5/mo | 30,000 | Yes (opt-in) | \$0.30 |
| Creator | \$22/mo | 100,000 | Yes | \$0.24 |
| Pro | \$99/mo | 500,000 | Yes | \$0.15 |
| Scale | \$330/mo | 2,000,000 | Yes | \$0.10 |
When you attach the credit to each product, turn off **Import Default Credit Settings**. You can then set this tier's own **Price Per Unit** for overage. Because one credit is one character, enter the per-character price: \$0.24 per 1K characters is \$0.00024 per credit. Set **Overage Behavior** to **Bill overage at billing**, and set a **Low Balance Threshold** at 10% of the tier's quota.
The usage meter connects activity in your application to the credit balance.
1. Create a meter with the event name `tts.characters`.
2. Set **Aggregation** to **Sum** and **Over Property** to `characters`. The meter adds up the `characters` value from every event.
3. On your usage-based product, toggle **Bill usage in Credits** and select the "Characters" credit.
4. Set **Meter units per credit** to 1, so one character used in your app deducts one credit.
Send an event to Dodo Payments each time a user generates audio.
```typescript theme={null}
import DodoPayments from 'dodopayments';
async function trackGeneration(
customerId: string,
text: string,
service: 'tts' | 'dubbing' | 'cloning'
) {
const characterCount = text.length;
const client = new DodoPayments({
bearerToken: process.env.DODO_PAYMENTS_API_KEY,
});
await client.usageEvents.ingest({
events: [{
event_id: `gen_${Date.now()}_${Math.random().toString(36).slice(2)}`,
customer_id: customerId,
event_name: 'tts.characters',
timestamp: new Date().toISOString(),
metadata: {
characters: characterCount,
service: service,
voice_id: 'voice_abc123'
}
}]
});
}
```
Use webhooks to tell users about their character usage.
```typescript theme={null}
import DodoPayments from 'dodopayments';
import express from 'express';
const app = express();
app.use(express.raw({ type: 'application/json' }));
const client = new DodoPayments({
bearerToken: process.env.DODO_PAYMENTS_API_KEY,
webhookKey: process.env.DODO_PAYMENTS_WEBHOOK_KEY,
});
// notifyUser and logUsage are your application's own functions.
app.post('/webhooks/dodo', async (req, res) => {
try {
const event = client.webhooks.unwrap(req.body.toString(), {
headers: {
'webhook-id': req.headers['webhook-id'] as string,
'webhook-signature': req.headers['webhook-signature'] as string,
'webhook-timestamp': req.headers['webhook-timestamp'] as string,
},
});
switch (event.type) {
case 'credit.balance_low':
await notifyUser(event.data.customer_id,
'You are running low on characters. Consider upgrading your plan for more characters and lower overage rates.'
);
break;
case 'credit.deducted':
await logUsage(event.data);
break;
case 'credit.overage_charged':
await notifyUser(event.data.customer_id,
'You have exceeded your character quota. Overage charges will appear on your next invoice.'
);
break;
}
res.json({ received: true });
} catch (error) {
res.status(401).json({ error: 'Invalid signature' });
}
});
```
When a user is ready to subscribe, create a checkout session for the chosen tier. This snippet reuses the `client` from the webhook step.
```typescript theme={null}
const session = await client.checkoutSessions.create({
product_cart: [
{ product_id: 'pdt_elevenlabs_pro', quantity: 1 }
],
customer: { email: 'creator@example.com' },
return_url: 'https://yourapp.com/dashboard'
});
```
## Accelerate with the Stream Ingestion Blueprint
To track audio output alongside character-based billing, use the [Stream Ingestion Blueprint](/developer-resources/ingestion-blueprints/stream). It meters the bytes each generation produces.
```bash theme={null}
npm install @dodopayments/ingestion-blueprints
```
```typescript theme={null}
import { Ingestion, trackStreamBytes } from '@dodopayments/ingestion-blueprints';
const ingestion = new Ingestion({
apiKey: process.env.DODO_PAYMENTS_API_KEY,
environment: 'live_mode',
eventName: 'tts.audio_bytes',
});
// generateSpeech, text, voiceId, and customerId come from your application.
const audioBuffer = await generateSpeech(text, voiceId);
await trackStreamBytes(ingestion, {
customerId: customerId,
bytes: audioBuffer.byteLength,
metadata: {
voice_id: voiceId,
service: 'tts',
format: 'mp3',
},
});
```
The byte counts show the infrastructure cost of each generation, while the character-based credits handle billing.
Each `trackStreamBytes` call sends one event. See the [full blueprint documentation](/developer-resources/ingestion-blueprints/stream) for more usage patterns.
## Upgrade Incentive: Tiered Overage Pricing
ElevenLabs uses overage rates to drive upgrades. Because each extra character costs less on a higher tier, the question changes from "how much do I need?" to "how much can I save?".
| Tier | Included Chars | Overage (per 1K) | Effective Cost at 500K Chars |
| :- | :- | :- | :- |
| Creator | 100,000 | \$0.24 | \$22 + (400 \* \$0.24) = \$118 |
| Pro | 500,000 | \$0.15 | \$99 (No overage) |
A user who uses 500,000 characters a month on the Creator plan pays \$118 in subscription plus overage. The Pro plan covers the same usage for \$99, a saving of \$19 per month. As usage grows, upgrading becomes the cheaper choice.
To build this with Dodo Payments, turn off **Import Default Credit Settings** when you attach the credit to each subscription product. You can then set a different **Price Per Unit** for each tier and give your largest customers the lowest rates.
## Key Dodo Features Used
Manage character quotas, rollovers, and expirations.
Set up the recurring tiers that deliver monthly character allowances.
Track character consumption across your services.
Send high-volume usage data to Dodo Payments.
React to low balances and overage events.
Track audio streaming bandwidth for usage-based billing.
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.