DEV Community

Jaden Vo
Jaden Vo

Posted on Originally published at infinityme.dev

No ElevenLabs Coupon Code? I Sized My Plan With 40 Lines of Python Instead

#ad #ElevenAgentsPartner — I'm an ElevenLabs affiliate partner. Links in this post go to articles on my own site, infinityme.dev, and some of those pages contain affiliate links. If you buy through them I may earn a commission at no extra cost to you.

Every few weeks someone asks me for an "ElevenLabs coupon code." I went looking on the official site and didn't find one. Most coupon pages just repeat the offers that are already on the pricing page, and some of them list codes that don't work at checkout.

What does work is less exciting: use the official offers that actually exist, and stop paying for credits you don't use. The second part is an estimation problem, and estimation problems are easier with a few lines of Python than with guesswork.

All numbers below come from the ElevenLabs pricing page as it read on October 20, 2026. Prices exclude taxes and can change, so check the official page before you subscribe.

The offers that are actually on the pricing page

  • Free plan. $0, 10,000 credits a month, roughly 10 minutes of text to speech. It includes text to speech, speech to text, sound effects, voice design, music and 3 Studio projects. It does not include a commercial license; that starts on Starter.
  • First month of Creator at 50% off. $11 instead of $22 for the first month, then it renews at the normal price.
  • Annual billing. ElevenLabs says annual equals 10x the monthly price, so two months are free. Starter works out to $60/year instead of $72, Creator about $220 instead of $264.
  • Credit rollover. On paid plans, unused credits roll over for up to two months, so your balance can reach 3x your monthly quota, as long as you stay subscribed and don't downgrade or cancel.
  • Startup Grants Program. 12 months free with 33M characters, by application, aimed at startups building conversational AI agents. It's not a creator discount.

That's the whole list. Everything else is about not overbuying.

The plan table, as data

This is the part I kept looking up, so I put it in a list:

Plan Monthly Credits/month Approx. TTS minutes
Free $0 10,000 ~10
Starter $6 30,000 ~30
Creator $22 (first month $11) 121,000 ~121
Pro $99 600,000 ~600
Scale $299 1,800,000 ~1,800
Business $990 6,000,000 ~6,000

Credits are shared across text to speech, sound effects, music, dubbing and the other tools. For standard multilingual text to speech, one character is roughly one credit, and a minute of narration is about 1,000 characters.

Estimate your real usage from your scripts

If you already write scripts as text files, you have everything you need to size a plan. This script counts characters per script, multiplies by how many you publish a month, adds a buffer for retakes, and prints the smallest paid plan that fits:

#!/usr/bin/env python3
"""Estimate monthly ElevenLabs TTS credits from a folder of scripts.

Plan numbers copied from elevenlabs.io/pricing (checked Oct 20, 2026).
Edit PLANS if the pricing page changes.
"""
import sys
from pathlib import Path

PLANS = [  # name, monthly USD, credits per month
    ("Free", 0, 10_000),
    ("Starter", 6, 30_000),
    ("Creator", 22, 121_000),
    ("Pro", 99, 600_000),
    ("Scale", 299, 1_800_000),
    ("Business", 990, 6_000_000),
]
RETAKE_BUFFER = 0.20  # retakes cost credits too


def credits_for(text: str) -> int:
    # Standard multilingual TTS: roughly one character = one credit.
    return len(" ".join(text.split()))


def pick_plan(needed: int, commercial: bool = True):
    for name, price, credits in PLANS:
        if commercial and name == "Free":
            continue  # no commercial license on Free
        if credits >= needed:
            return name, price, credits
    return PLANS[-1]


def main(folder: str, uploads_per_month: float = 4) -> None:
    files = sorted(Path(folder).glob("*.txt"))
    if not files:
        sys.exit(f"no .txt scripts in {folder}")
    per_script = [credits_for(p.read_text(encoding="utf-8")) for p in files]
    avg = sum(per_script) / len(per_script)
    needed = int(avg * uploads_per_month * (1 + RETAKE_BUFFER))
    name, price, credits = pick_plan(needed)
    print(f"{len(files)} scripts, avg {avg:,.0f} chars (~{avg / 1000:.1f} min)")
    print(f"~{needed:,} credits/month incl. {RETAKE_BUFFER:.0%} retakes")
    print(f"smallest paid plan that fits: {name} (${price}/mo, {credits:,} credits)")


if __name__ == "__main__":
    main(sys.argv[1], float(sys.argv[2]) if len(sys.argv) > 2 else 4)
Enter fullscreen mode Exit fullscreen mode

Run it against a folder of Shorts scripts at 12 a month:

$ python3 credit_budget.py scripts/ 12
4 scripts, avg 1,833 chars (~1.8 min)
~26,395 credits/month incl. 20% retakes
smallest paid plan that fits: Starter ($6/mo, 30,000 credits)
Enter fullscreen mode Exit fullscreen mode

A few notes so you don't trust it more than you should:

  • It collapses whitespace before counting, because double spaces and blank lines in a text file aren't what you paste into the editor. Your stage directions and notes to yourself are a different story: strip them first or they'll be counted.
  • The 20% retake buffer is my own habit, not an ElevenLabs number. Credits are charged per generation, not per download, so every "one more try" costs money. If you retake a lot, raise it.
  • It only counts text to speech. If you also use dubbing, sound effects or music, those draw from the same balance.

The pricing page's own rough guide lines up with this: a few Shorts a week fits under 30,000 credits (Starter), one 10–15 minute video a week is around 50,000–70,000 (Creator), and daily long-form or client work is 300,000+ (Pro). Still, check your real usage on the subscription page after a couple of weeks. The script is a starting point, not a bill.

Model rollover before you upgrade

Rollover is the feature people forget when they upgrade "just in case." If you publish in bursts, a smaller plan plus banked credits can cover a big month. Here's the rule as a tiny simulation:

def simulate(monthly_quota, usage):
    """Paid plans: unused credits roll over up to two months,
    so the balance never exceeds 3x the monthly quota."""
    balance, history = 0, []
    for used in usage:
        balance = min(balance + monthly_quota, 3 * monthly_quota)
        balance -= used
        if balance < 0:
            history.append(f"short by {-balance:,}")
            balance = 0
        else:
            history.append(f"{balance:,} left")
    return history


# Starter quota, a quiet month, a quiet month, then a big batch
print(simulate(30_000, [5_000, 8_000, 70_000]))
# ['25,000 left', '47,000 left', '7,000 left']
Enter fullscreen mode Exit fullscreen mode

Two quiet months on Starter covered a 70,000-credit month that would have looked like a Creator-sized month on its own. This is a simplified model (it treats the 3x cap as the only limit and doesn't track which month each credit came from), so use it to reason, not to forecast to the credit.

Two things the simulation doesn't show but you should know:

  • Downgrading or cancelling forfeits unused credits at the end of the cycle. Spend the bank before you switch plans.
  • Pay-as-you-go top-ups are separate and aren't subject to the rollover cap.

Waste fewer credits

Since retakes are billed, most of the savings come before you press generate:

  • Proofread the script first. Fix typos, numbers and names before generating.
  • Generate in sections, so one bad sentence doesn't mean re-rendering the whole thing.
  • Watch for free regenerations. ElevenLabs says a limited number may be available if the content and certain settings don't change, and the app shows when one is free.
  • Lock your voice settings once you like them instead of experimenting on every video.

The order I'd do it in

  1. Week 1: Free plan. Test voices and settings on the same 150–200-word script. Don't publish anything commercial from it.
  2. First paid month: Starter if you only need commercial rights for short content, or Creator at the first-month price if you want to train a Professional Voice Clone.
  3. Months 2–3: run the numbers on real usage and right-size.
  4. After that: switch to annual on the plan you actually use.

And skip any site that wants your card details for a "discount." Sign up directly on elevenlabs.io and use what's listed there.

The full guide, with the plan-size table and the FAQ on rollover and the startup grants, is here: ElevenLabs discount and free trial (2026).

Top comments (0)