> ## 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 has built a dominant position in the AI voice space by making their billing as fluid as their speech synthesis. Their model centers on a single unit of value: the character. Whether you are generating text-to-speech, cloning a voice, or dubbing a video, you consume from a unified pool of character credits. ## How ElevenLabs Bills The ElevenLabs pricing structure uses fixed monthly quotas tied to subscription tiers. As users move to higher tiers, they get more characters and access to more advanced features like professional voice cloning or commercial rights. | Plan | Price | Characters/Month | Overage Rate | | :------ | :---------- | :--------------- | :---------------- | | Free | \$0 | 10,000 | Not available | | Starter | \$5/month | 30,000 | \~\$0.30/1K chars | | Creator | \$22/month | 100,000 | \~\$0.24/1K chars | | Pro | \$99/month | 500,000 | \~\$0.15/1K chars | | Scale | \$330/month | 2,000,000 | \~\$0.10/1K chars | 1. **Character-based pricing**: Characters are the universal currency across the platform. Text-to-Speech, Dubbing, and Voice Cloning all draw from this same balance, simplifying usage tracking. 2. **Rollover mechanics**: Unused characters roll over to the next billing cycle instead of expiring. ElevenLabs applies a cap to prevent infinite accumulation, ensuring users retain value from their subscription. 3. **Tiered overages**: Overages are handled based on the subscription tier. Lower plans have overages disabled by default for safety, while higher tiers allow opt-in charges to maintain service continuity. ## What Makes It Unique Several strategic choices make the ElevenLabs billing model particularly effective for retaining users and encouraging upgrades. * **Character Rollover**: Rollover credits reduce "use it or lose it" anxiety by carrying forward unused investment. This maintains subscription value even during periods of lower activity. * **Tiered Overage Pricing**: Overage rates decrease as plan sizes increase, creating a strong incentive to upgrade. Users often find higher tiers more attractive due to the lower cost of additional usage. * **Unified Consumption**: A single character pool for all services removes the cognitive burden of managing separate quotas. Users only need to track one number to understand their remaining capacity. * **Opt-in Overages**: Professional users can enable overages for continuity, while casual users benefit from the safety of a hard cap. ```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 replicate this sophisticated model using Dodo Payments' credit-based billing and usage metering. First, define the "Characters" unit that will serve as your platform's currency. 1. Go to **Entitlements** in your Dodo dashboard. 2. Create a new **Credit Entitlement**. 3. Set the **Credit Type** to **Custom Unit**. 4. Name the unit "Characters". 5. Set **Precision** to 0, as characters are always 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% (allows all unused characters to carry over). * **Rollover Timeframe**: 1 Month. * **Max Rollover Count**: 1 (credits can roll over once, then they expire). Create five subscription products. You will attach the same "Characters" entitlement to each, but with different configurations for each 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 entitlement to each product, uncheck **Import Default Credit Settings**. This allows you to set the specific **Price Per Unit** for overages on that specific tier. Set the **Overage Behavior** to **Bill overage at billing** and configure a **Low Balance Threshold** at 10% of the tier's quota. The usage meter connects your application's activity to the credit system. 1. Create a new meter named `tts.characters`. 2. Set the **Aggregation** to **Sum**. This will add up the `characters` property from every event you send. 3. Link this meter to your "Characters" credit entitlement. 4. Set **Meter units per credit** to 1. This ensures that one character used in your app equals one credit deducted from the balance. Integrate the usage tracking into your application code. Every time a user generates audio, send an event to Dodo. ```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 keep your users informed 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, }); 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. ```typescript theme={null} const session = await client.checkoutSessions.create({ product_cart: [ { product_id: 'prod_elevenlabs_pro', quantity: 1 } ], customer: { email: 'creator@example.com' }, return_url: 'https://yourapp.com/dashboard' }); ``` ## Accelerate with the Stream Ingestion Blueprint For tracking audio output alongside character-based billing, the [Stream Ingestion Blueprint](/developer-resources/ingestion-blueprints/stream) provides a streamlined way to meter bandwidth consumption. ```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', }); // After generating audio, track the output size const audioBuffer = await generateSpeech(text, voiceId); await trackStreamBytes(ingestion, { customerId: customerId, bytes: audioBuffer.byteLength, metadata: { voice_id: voiceId, service: 'tts', format: 'mp3', }, }); ``` Use the Stream Blueprint to track audio bandwidth alongside your character-based credit system. This gives you visibility into actual infrastructure costs per generation. The Stream Blueprint also supports batching for high-volume scenarios. See the [full blueprint documentation](/developer-resources/ingestion-blueprints/stream) for advanced usage patterns. ## Upgrade Incentive: Tiered Overage Pricing The most brilliant part of the ElevenLabs model is how it uses overage rates to drive upgrades. By making the cost per character cheaper on higher tiers, they change the conversation 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 regularly consumes 500,000 characters on the Creator plan pays \$118 per month in subscription plus overages. Upgrading to the Pro plan covers the same usage for \$99, saving \$19 per month. The lower overage rate on higher tiers means that as usage grows, upgrading becomes the obvious financial decision. With Dodo Payments, you implement this by unchecking the **Import Default Credit Settings** box when attaching credits to your subscription products. This gives you full control over the **Price Per Unit** for each specific tier, allowing you to reward your highest-paying customers with the best rates. ## Key Dodo Features Used Manage character quotas, rollovers, and expirations. Set up the recurring tiers that deliver monthly character allowances. Track real-time character consumption across your services. Send high-volume usage data to Dodo with minimal latency. React to low balances and overage events in real-time. Track audio streaming bandwidth for usage-based billing.