AI writing assistant token costs: what each user actually costs you

Quick answer: a paid seat costs cents, not dollars, if you route well.

Every generation your product runs is billed twice: once for input tokens (your system prompt, the brand voice profile, the user brief, any source material) and once for output tokens (the draft itself). Output rates run roughly 2 to 6 times the input rate on most models, and a writing tool is one of the few LLM products where output is the bigger line item, because long generated text is exactly what users came for. A single short asset like a product description costs a fraction of a cent on a budget model and a couple of cents on a flagship. The monthly picture follows from volume. Model a typical paid seat as 60 generations a month across short assets, rewrites, and long-form sections: roughly 100K input and 35K output tokens. On deepseek-v4-flash that seat costs about $0.02 a month. On claude-sonnet-4-6 the same seat costs about $0.66. Against a $19 subscription both look small, until you multiply by regenerations, power users, and a free tier that pays you nothing. You have three levers as an operator. Route each asset type to the cheapest model that clears your quality bar. Control the hidden multipliers: regenerations, rewrite loops, and bloated standing prompts. And lower the unit rate itself by changing where the tokens are billed. The rest of this page works through each lever with real numbers.

Where the money goes in a writing product.

This cost shape is the opposite of coding agents, where a growing context window makes input the dominant charge. A writing assistant sends a comparatively small, stable prompt and buys mostly output, which is priced at the expensive end of every model's rate card. That is why per-model output price matters more to your COGS than headline input price. The trap is that the input side quietly grows anyway. Teams add a longer brand guide, a second style example, a compliance checklist, and suddenly every 350-token product blurb rides on 3K tokens of standing prompt. None of it is visible to the user, all of it is billed on every request, and it compounds across every seat you sell.

• System prompt and output-format instructions: sent with every single generation, for every user, forever.
• Brand voice profile and style examples: commonly 1K to 3K tokens riding along on every request once a workspace has configured them.
• The user brief plus pasted source material: interviews, outlines, and reference articles all bill as input.
• The existing draft: every rewrite, expand, or tone-shift pass re-sends the current text as input before it writes a word.
• Regenerations: each click on regenerate bills the full input and output price, and only one version ships.

Worked example: what one seat costs per month.

Price it from asset profiles instead of guessing. A short asset (email, ad copy, product description) runs about 1,200 input and 350 output tokens once you count the standing prompt. A rewrite pass re-sends the draft, call it 2,000 input and 600 output. A long-form section (blog or article block) runs about 2,500 input and 1,200 output. A typical paid seat doing 30 short assets, 20 rewrites, and 10 long-form sections lands near 100K input and 35K output tokens a month. The table prices three seat profiles at the cheap and premium ends of the catalog. The spread is the whole story: on the budget model even a power seat costs about a dime, while an all-flagship power seat costs $3.30, which is about 17% of a $19 subscription. The typical all-flagship seat at $0.66 is about 3.5% of revenue, tolerable on its own, fragile once regeneration behavior or free riders stack on top.

Why writing-product token bills surprise operators.

The last point is the structural one. Your heaviest users are usually your best advocates and worst unit economics at the same time, so a hard cutoff is rarely the answer. The workable fix is per-user token telemetry: log input and output tokens per request against a user ID, watch the distribution, and design plan limits around tokens you can see rather than document counts that hide the variance.

• The regeneration multiplier: users click regenerate 2 to 4 times on assets they care about, so the billed cost per shipped word is a multiple of the naive per-asset math.
• Rewrite loops re-send the whole document: an "expand this section" click on a 3,000-word draft bills the full draft as input, every time.
• Document metering hides token variance: a 200-word blurb and a 3,000-word article both count as "one document" in your plan limits, but differ by an order of magnitude in tokens.
• Free tiers attract scripted extraction: throwaway signups farming generations cost real output tokens against zero revenue.
• A silent model upgrade reprices every seat: switching the default from a budget model to a flagship multiplies COGS across the whole base overnight.
• Revenue is flat, cost is metered: subscriptions cap what a user pays you, nothing caps what a user costs you.

Model comparison: seat COGS across the catalog.

The table prices the same typical seat (100K input, 35K output per month) across models suited to writing workloads. The practical reading: short-form assets rarely justify flagship prose, because a subject line does not showcase what a top model does better. Long-form drafts and brand-critical hero copy are where quality differences show, and where the premium rates earn their keep. Most profitable writing products run a ladder, not a single model.

How to protect gross margin without gutting quality.

The routing and unit-rate levers compound. One gateway option is APIsRouter, an OpenAI-compatible API with pay-as-you-go billing and no subscription: global models are priced 20% below official list, Chinese models sit below their official rates, the first top-up adds +100% balance, and the checkout at /topup takes payment first and emails the key. Concretely: keep claude-sonnet-4-6 for the 10 long-form sections and push the 50 short and rewrite generations to deepseek-v4-flash, and the typical seat drops from $0.66 to about $0.22 a month. Across 1,000 paid seats that is roughly $440 a month back, and the long-form work still ships flagship prose.

• Route by asset type. Send blurbs, emails, and meta descriptions to a budget model, blog sections to a mid-tier, and reserve the flagship for hero copy or a paid "premium quality" toggle users opt into.
• Cap the regeneration multiplier. Offer two free regenerations per asset, then either route further attempts to a cheaper model or charge a plan credit.
• Meter the free tier in tokens, not documents. Set a hard monthly token cap per account, throttle disposable-email domains, and run the free tier on your cheapest acceptable model.
• Shrink the standing prompt. Compress the brand voice guide into a few hundred tokens of bullets; a 3K-token style essay on every request is a permanent tax on every seat.
• Edit, do not regenerate. For section-level changes, send only the target section plus a one-paragraph summary of the document instead of the full draft.
• Set max_tokens per asset type. A headline request should not be able to bill 2,000 output tokens because a model rambled.
• Lower the unit rate itself by routing traffic through a cheaper OpenAI-compatible endpoint instead of paying official list prices for the same model IDs.

Implementation: one client, per-asset routing and caps.

Because the endpoint is OpenAI-compatible, routing is configuration, not architecture. Keep one client, hold the model ladder in a config map keyed by asset type, and set max_tokens per route so cost ceilings are enforced at the API call. Log usage from every response against the requesting user ID; that telemetry is what turns plan design and abuse detection from guesswork into arithmetic. Verify the key and a model ID with a one-off request before wiring it into the product:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.apisrouter.com/v1",
    api_key=os.environ["LLM_API_KEY"],
)

ROUTES = {
    "short_form": {"model": "deepseek-v4-flash", "max_tokens": 600},
    "rewrite": {"model": "deepseek-v4-flash", "max_tokens": 900},
    "long_form": {"model": "claude-sonnet-4-6", "max_tokens": 1800},
}

def generate(asset_type: str, system: str, brief: str, user_id: str):
    route = ROUTES[asset_type]
    resp = client.chat.completions.create(
        model=route["model"],
        max_tokens=route["max_tokens"],
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": brief},
        ],
    )
    log_usage(user_id, asset_type, resp.usage)  # prompt_tokens, completion_tokens
    return resp.choices[0].message.content

FAQ