You have added avatar video to your product and now you need to put a price on it. Charge too little and heavy users eat your margin; charge too much, or in a confusing unit, and nobody turns the feature on. Unlike most SaaS features, every video has a real marginal cost, so the pricing model has to account for usage.
This guide compares the common pricing models, works through the margin math for each with hypothetical plans, and covers the guardrails that keep a plan profitable. Provider costs use PitchTwin's public pack prices; swap in your own.
Start from your cost per minute
Before choosing a model, know what one minute of video costs you. With PitchTwin, one token is one second of video with your own audio, and 1.5 tokens per second when PitchTwin voices the script. On the Scale pack ($149 for 12,000 tokens, about $0.01242 per token):
Own audio: 60 tokens × $0.01242 ≈ $0.74 per minute
Our voice: 90 tokens × $0.01242 ≈ $1.12 per minute
A useful rule for setting price from cost:
price = cost ÷ (1 − target gross margin)
70% margin, voiced: $1.12 ÷ 0.30 ≈ $3.73 per minute
70% margin, own audio: $0.74 ÷ 0.30 ≈ $2.47 per minute
That is your floor for a 70% margin before payment fees and support. Everything below is a way to package that number so customers understand it.
Model 1: an allowance inside existing plans
The simplest option: each plan includes a number of videos or minutes per month, with no separate line item.
Hypothetical example. Your Pro plan is $149 per month and includes 20 minutes of voiced video.
Worst case: 20 min × $1.12 = $22.40 per customer
Share of plan price: $22.40 ÷ $149 ≈ 15%
Good for: products where video is one feature among many, such as a training platform or a CS tool.
Watch out for: customers who buy the plan only for video. Cap the allowance, and offer more through an add-on rather than raising the cap for everyone.
Model 2: a video add-on pack
Customers buy a block of video minutes on top of their plan.
Hypothetical example. You sell 30 voiced minutes for $49.
Cost: 30 min × 90 tokens = 2,700 tokens × $0.01242 ≈ $33.53
Payment fee: $49 × 0.029 + $0.30 ≈ $1.72 (Stripe standard US card rate)
Margin: $49 − $33.53 − $1.72 = $13.75
$13.75 ÷ $49 ≈ 28%
The payment fee uses Stripe's published 2.9% + 30¢ standard rate. A 28% margin is thin. Raising the price to $79:
Payment fee: $79 × 0.029 + $0.30 ≈ $2.59
Margin: $79 − $33.53 − $2.59 = $42.88
$42.88 ÷ $79 ≈ 54%
Or offer the same 30 minutes using your own text-to-speech in audio mode, which costs 1,800 tokens (≈ $22.36) plus your audio provider's cost.
Good for: products with a few heavy users and many light ones.
Model 3: credits per video
Customers spend one credit per video, regardless of length, up to a cap. This is easy to explain ("100 videos") but the cost varies with length.
Hypothetical example. 100 credits for $199, each video up to 60 seconds, voiced.
Worst case (every video 60 s):
100 × 90 tokens = 9,000 tokens × $0.01242 ≈ $111.78
Fee: $199 × 0.029 + $0.30 ≈ $6.07
Margin: ($199 − $111.78 − $6.07) ÷ $199 ≈ 41%
Typical case (average 40 s):
100 × 60 tokens = 6,000 tokens × $0.01242 ≈ $74.52
Margin: ($199 − $74.52 − $6.07) ÷ $199 ≈ 60%
Good for: outbound and SDR tools, where the customer thinks in "videos sent", not minutes.
Watch out for: the length cap. Without one, a single credit could be a 10-minute video. Enforce it before you call the API, not after.
Model 4: per-second metered billing
Charge the customer for exact output duration, usually against a prepaid balance in your own app.
Hypothetical example. You charge $0.05 per voiced second, which is $3.00 per minute.
Cost per minute: $1.12
Margin per minute: ($3.00 − $1.12) ÷ $3.00 ≈ 63% before fees
Good for: API-style products and platforms whose customers are themselves developers.
Watch out for: sticker shock. Per-second prices look small and then add up, and non-technical buyers find them hard to budget.
Comparing the models
| Model | Easy to explain | Margin predictability | Best for |
|---|---|---|---|
| Allowance in plan | High | Medium (capped) | Video as one feature among many |
| Add-on pack | High | High | Mixed light and heavy users |
| Credits per video | High | Medium (depends on length cap) | SDR and outreach tools |
| Per-second metered | Low for non-technical buyers | High | Developer platforms |
Many products combine two: an allowance in each plan, plus add-on packs for heavy users.
Guardrails that protect your margin
Estimate length before rendering
When you voice scripts, you do not know the exact duration until the video renders. Estimate it from word count so you can enforce caps and show the customer a cost. A planning assumption of around 150 words per minute is a reasonable starting point; replace it with your own data from duration_ms once you have real renders.
Charge on actual output
After rendering, bill the customer on what was produced. Each finished generation returns duration_ms and tokens_charged. Here is a webhook handler in Node that verifies the signature, then debits the customer's balance in whole seconds:
import crypto from "node:crypto";
import express from "express";
const app = express();
const SECRET = process.env.PITCHTWIN_WEBHOOK_SECRET!;
function verify(rawBody: Buffer, header: string | undefined): boolean {
if (!header) return false;
const parts = Object.fromEntries(header.split(",").map((p) => p.split("=") as [string, string]));
const expected = crypto
.createHmac("sha256", SECRET)
.update(`${parts.t}.${rawBody.toString("utf8")}`)
.digest("hex");
const a = Buffer.from(expected);
const b = Buffer.from(parts.v1 ?? "");
return a.length === b.length && crypto.timingSafeEqual(a, b);
}
app.post("/webhooks/pitchtwin", express.raw({ type: "application/json" }), async (req, res) => {
if (!verify(req.body, req.header("PitchTwin-Signature"))) return res.sendStatus(400);
const event = JSON.parse(req.body.toString("utf8"));
if (event.type === "generation.succeeded") {
const seconds = Math.ceil(event.data.duration_ms / 1000);
await debitCustomer(event.data.id, seconds, event.data.tokens_charged);
}
res.sendStatus(200);
});
debitCustomer is your own function. Storing tokens_charged alongside the customer debit gives you cost and revenue on the same row. Webhooks are delivered once, so also poll GET /generations/:id for any job that has not reported back. More detail is in the webhooks docs.
Do not charge for failures
If a generation fails, PitchTwin refunds the tokens automatically. Pass that through: when you receive generation.failed, release any credit you reserved for the customer.
Decide on rollover
PitchTwin tokens never expire, so your own provider balance carries no use-it-or-lose-it risk. That leaves you free to choose rollover for customer credits based on your business model, not your supplier's.
Keep free tiers small and specific
A free tier that includes a few short videos lets customers see their own avatar on screen, which is what sells the feature. Size it as an acquisition cost: for example, 3 voiced videos of 30 seconds is 135 tokens, about $1.68 per trial user at Scale pricing.
A sensible default
If you are unsure, start here:
- Include a modest allowance in paid plans.
- Sell add-on packs priced for at least a 50% margin at full use.
- Cap video length per request.
- Bill from
duration_ms, refund failures, and logtokens_chargedper customer.
Then revisit after a quarter of real usage. For the full margin model behind these numbers, see unit economics of AI avatar products, and for per-recipient video use cases, see the personalized video API.
Try it
Sign up for 60 free seconds of video with no card, render a few test scripts in the Playground, and compare duration_ms against your length estimates. That gives you real numbers to price from.