Murf bills AI voiceover by the second, ElevenLabs by the character. I did the arithmetic to find where each one wins.

I generate a lot of synthetic speech for side projects, and I keep two text-to-speech subscriptions open: Murf and ElevenLabs. For a long time I treated "which is cheaper" as a fixed fact — one number versus another. It isn't. The two tools meter you on different units, and once you notice that, the cheaper tool stops being a property of the price page and becomes a property of your script.

Here is the whole thing in one sentence: Murf charges you for the duration of the audio, ElevenLabs charges you for the characters in the text. A pause costs money on one and nothing on the other. I modeled it to find exactly where the line falls, and the answer surprised me enough to write it down.

Two meters

• Murf meters "voice generation time" — you get a fixed budget of audio hours per month (2 hours on the $29 Creator plan), and every second of generated speech draws it down, regardless of what's in it.
• ElevenLabs meters credits, where 1 credit = 1 character of input text on the standard multilingual model (121,000 credits/month on the $22 Creator plan). Silence, pauses, and slow delivery cost nothing extra — they aren't characters.

So the natural unit to reason in is characters per second of audio — how densely you pack text into time. Call it cps. A rapid ad read crams a lot of characters into each second; a paced e-learning module with breathing room spreads few characters over many seconds. Same words, different cps, depending on delivery.

Normalize both meters to a common basis and the asymmetry pops out:

@dataclass(frozen=True)
class DurationPlan:        # Murf — billed per second of audio
    name: str
    price: float
    hours_per_month: float
    def dollars_per_audio_hour(self, cps: float) -> float:
        return self.price / self.hours_per_month   # cps is irrelevant here

@dataclass(frozen=True)
class CharPlan:            # ElevenLabs — billed per character
    name: str
    price: float
    chars_per_month: int
    def dollars_per_char(self) -> float:
        return self.price / self.chars_per_month
    def dollars_per_audio_hour(self, cps: float) -> float:
        return self.dollars_per_char() * cps * 3600   # cps drives the cost

Look at the two dollars_per_audio_hour methods. Murf's ignores cps — it's a flat rate per hour of audio. ElevenLabs' is linear in cps. One is a horizontal line, the other is a ray through the origin. Two lines cross exactly once, and that crossing is the whole story.

Unit costs (the meters, normalized):
  ElevenLabs : $0.182 per 1,000 characters
  Murf       : $14.50 per audio-hour (monthly), $9.50 per audio-hour (annual)

The break-even is a speaking density

Set Murf's flat $/hour equal to ElevenLabs' cps-driven $/hour and solve for cps:

def breakeven_cps(dplan, cplan):
    flat_per_hour = dplan.dollars_per_audio_hour(0)        # density-independent
    return flat_per_hour / (cplan.dollars_per_char() * 3600)

Break-even speaking density (characters per second of audio):
  vs Murf Creator (monthly)  :  22.2 cps
  vs Murf Creator (annual)   :  14.5 cps
  Below the break-even, ElevenLabs is cheaper; above it, Murf is.

Now the numbers mean something. Below the break-even density, ElevenLabs wins; above it, Murf does. So how dense is real speech? Natural English narration runs about 13–16 cps; a brisk, dense read pushes toward 18–20; a paced read with deliberate pauses drops to 10–12. (You don't have to trust me — cps is just characters / audio_seconds, so you can measure it on any clip you've already made.)

Hold that against the two break-evens:

• Murf monthly breaks even at 22.2 cps — higher than essentially all real speech. On monthly billing, ElevenLabs is cheaper for basically anything you'd actually narrate.
• Murf annual breaks even at 14.5 cps — right in the middle of the real range. Now it's a genuine coin-flip that depends on your delivery.

Sweeping a realistic range of content makes it concrete (cps is the input you'd measure from your own audio, so I sweep it rather than pretend there's one true value):

content type                       cps  EL $/hr  Murf mo  Murf yr  cheapest
---------------------------------------------------------------------------
Slow, paused e-learning            9.5     6.22    14.50     9.50  ElevenLabs
Measured narration / explainer    12.5     8.18    14.50     9.50  ElevenLabs
Audiobook, natural pace           15.0     9.82    14.50     9.50  Murf annual
Conversational / podcast          16.5    10.80    14.50     9.50  Murf annual
Brisk ad read                     19.0    12.44    14.50     9.50  Murf annual
Rapid dense voiceover             22.5    14.73    14.50     9.50  Murf annual

(One honest caveat: Murf's flat $9.50/$14.50 per hour assumes you actually use the full 2-hour budget. It doesn't roll over, so if you generate less, your real per-hour cost is higher than the table — never lower. ElevenLabs unused credits also expire, but the per-character price is the per-character price whether you use 10 or 10,000.)

Pauses are the punchline

Here's the part that made me laugh. Murf's pitch to e-learning teams leans hard on its delivery controls — insert exact pauses, slow the pace, let a sentence breathe. Good instructional design. But a pause is free characters and paid seconds, which means every bit of that polish drags you down the cps axis, toward the region where Murf is the more expensive meter.

Take one minute of narration at 15 cps and add 12 seconds of deliberate pauses — about a one-second beat every five seconds, which is normal for teaching:

Cost of 12s of deliberate pauses on a 60s, 900-char narration:
  before: 60s audio, 900 chars -> 15.0 cps
  after : 72s audio, 900 chars -> 12.5 cps
  Murf (monthly): $0.2417 -> $0.2900  (+20% -- you pay for the silence)
  ElevenLabs    : $0.1636 -> $0.1636  (+0% -- pauses are free characters)

The script didn't change — same 900 characters. The pacing did, and on a duration meter pacing is the bill. The exact feature that makes Murf good for paced instructional content is the feature that makes its meter the wrong one for paced instructional content. That's not a knock on the voices; it's a property of charging by the second.

This is why the head-to-head verdict on Murf is so delivery-dependent rather than a flat "cheaper/pricier," and the meter is only half of it — the other half is whether the studio around the voice (the timeline, the music library, the project system) earns the subscription regardless of the per-hour math. I went through all of that the slow way in a full hands-on Murf AI review, and the short version is that Murf sells the studio, not the per-character price — which lines up exactly with what the arithmetic here says.

Takeaways for anyone comparing metered tools

• Check the unit before the price. Two tools quoted in different units (seconds vs characters, requests vs tokens, rows vs gigabytes) can't be compared by their headline numbers. Normalize to a shared basis first; the cheaper one often flips.
• A flat meter and a usage meter cross exactly once. Find that crossing and you've turned "it depends" into a single threshold you can check your real workload against.
• The binding variable is usually one you don't control on the price page. Here it's your speaking density — a property of your content, not the vendor's. Measure it (characters / audio_seconds) before you commit to a year.
• Watch for features that fight the meter. When the thing a tool is good at (pauses, retries, verbose output) is billed by the axis that thing inflates, the value proposition quietly works against you.

The whole model is ~90 lines of stdlib — swap in your own cps and plan numbers and it'll tell you which meter you're really on. And if you've found a worse unit mismatch than billing narration by the second while selling pause controls, I'd love to read it in the comments.