AI companion app unit economics: what each user actually costs

Quick answer: per-user COGS runs from cents to double digits

The unit economics of a companion app compress into one line: monthly COGS per user equals messages per month, times input tokens per message at the input rate, plus output tokens per message at the output rate. Every headline about GPUs, context windows, and benchmark charts only reaches your P&L through those four numbers. Plug in realistic values and the range is enormous. A paying user who sends 40 messages a day, with about 4,000 input tokens and 200 output tokens per message, costs roughly $0.67 a month to serve on deepseek-v4-flash and about $14.40 a month on claude-sonnet-4-6 at the catalog rates used throughout this page. Same user, same behavior, a 21x spread in cost. On a $9.99 subscription, that spread is the difference between a 93% gross margin and losing money on every subscriber. You control three levers: shrink what gets resent on every message, route each subscription tier to the cheapest model that clears its quality bar, and lower the per-token rate you pay in the first place. The rest of this page works each lever with real numbers.

Where the money goes on every message

Run the arithmetic on that shape and input dominates. At 4,000 input and 200 output tokens per message, input is 95 percent of token volume, and even though output is priced several times higher per token, input still lands at 80 to 90 percent of the dollar bill on most models. Companion apps are input businesses: you are billed again and again for text the model has already seen. That inversion is what separates companion economics from utility chatbots. A support bot answers and forgets. A companion is valuable precisely because it remembers, and memory is implemented by resending the past as input tokens on every call. Retention grows histories, histories grow the resent window, and your most loyal users quietly become your most expensive ones unless you summarize and trim.

• Character card and system prompt: typically 1,000 to 2,500 tokens, resent with every single message for the life of the chat.
• Persona and long-term memory blocks: another 300 to 800 tokens, also resent every time.
• Recent chat history: the largest and fastest-growing slice; an untrimmed window can pass 10,000 tokens in one long evening session.
• The user message itself: usually under 100 tokens, a rounding error.
• The reply: 150 to 300 output tokens for chat-style companions; output rates are higher per token, but the volume is small.

Worked example: per-user COGS and margin on a $9.99 subscription

Assume a $9.99 monthly plan and a typical paying user: 40 messages a day at 4,000 input plus 200 output tokens per message. That is 1,200 messages, 4.8M input tokens, and 240K output tokens a month. The table prices that exact user on catalog models, cheapest first. Two readings matter. First, budget models serve a heavy chatter for well under a dollar, which is where sustainable free tiers and entry plans live. Second, the flagship row is not a typo: a $9.99 plan genuinely loses about $4.40 per typical subscriber on claude-sonnet-4-6 before payment fees. Flagship prose has a real audience, but it belongs in a higher-priced tier with output caps, not in your base plan. If you charge differently, the math scales linearly. The same user on a $14.99 plan lifts claude-haiku-4-5 from a 52% margin to about 68%, while the flagship row is still only a 28% margin even at $19.99. Unit economics work is mostly moving one of three numbers: the price, the message volume a plan tolerates, or the per-token rate.

Why companion app bills surprise founders

None of these failure modes show up in a demo, and all of them show up in week three of an invoice. The common thread is that companion usage is heavy-tailed: averages look fine while the top few percent of users and the longest few percent of chats carry most of the spend. Instrument per-user token usage from day one, because you cannot cap what you cannot see.

• Whales: an approximate power user sending 150 messages a day burns around 18M input tokens a month, which is over $50 in COGS on claude-sonnet-4-6 against a $9.99 plan.
• History creep: the same user costs about 2.3x more per message once the resent window grows from 4,000 to 10,000 tokens, so per-user cost climbs with engagement even when message counts stay flat.
• Free tier drain: 10,000 free users capped at 10 messages a day cost about $1,700 a month on mimo-v2.5 and about $36,000 a month on claude-sonnet-4-6. The model behind the free tier is an existential choice.
• Conversion math: at a low single-digit conversion rate, those 10,000 free users yield roughly 300 subscribers and about $3,000 in MRR, so a flagship-powered free tier can burn 12x the revenue it feeds.
• Bundled extras: an image model at $0.018 per call sounds trivial until one tier includes unlimited character selfies; media add-ons need their own caps and their own line in the COGS model.

Direct API, self-hosted, or gateway: three ways to buy inference

Where you buy inference sets the rate that multiplies everything above. For production traffic there are three real options. Consumer chat subscriptions are not one of them: flat-rate personal plans are licensed for personal use, not for serving an app's traffic, so they never belong in a COGS plan. Self-hosting deserves the honest caveat. Renting GPUs converts a variable cost into a fixed one, which is only a win at high, steady utilization; below that you pay for idle silicon, plus an inference-serving stack someone on your team now owns at 3 a.m. Most companion apps below millions of messages a day come out ahead buying tokens instead.

Seven levers that protect gross margin

The levers compound: halving input per message and paying a lower rate on top of it can cut per-user COGS by three quarters without touching perceived quality. On the rate lever, one option is APIsRouter, an OpenAI-compatible gateway with pay-as-you-go billing and no subscription: global models are priced 20% below official list, Chinese models sit below their official rates, and the first top-up adds +100% balance, which makes an A/B routing test cheap enough to run this week. Put together, a defensible tier ladder looks like this:

• Route by tier, not by vibes. The free tier and the top tier should almost never share a model; each tier gets the cheapest model that clears its quality bar.
• Summarize history past a budget. Keep the last 15 to 20 turns raw, compress everything older into a short memory block, and stop resending the whole transcript.
• Audit the character card. Every token in the card is billed on every message forever, so a 2,500-token card versus a 1,200-token card is a permanent difference in unit cost.
• Cap output with max_tokens. Companion replies read best at 150 to 300 tokens anyway, and output is your most expensive token class.
• Give each user a monthly token budget and degrade gracefully: shorten the memory window or move that user to a cheaper model instead of hard-blocking them mid-conversation.
• Alert on spend daily, per user. Whales should surface in a dashboard within 24 hours, not in next month's invoice.
• Lower the rate itself by routing traffic through a cheaper OpenAI-compatible endpoint; the same model IDs at a lower per-token price move every row of your margin table at once.

Config: tier routing and per-user metering in one place

Because the endpoint is OpenAI-compatible, tier routing is a dictionary lookup, not a replatform. One client, one key, and the model string is the only thing that changes between a free user and a top-tier subscriber. The same request path also returns a usage block on every response, and that block is your COGS ledger: write prompt and completion tokens to your database keyed by user ID, and the per-user margin dashboards and whale alerts from earlier sections fall out of a single GROUP BY. Verify the key and a model ID with curl before wiring anything into the app:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.apisrouter.com/v1",
    api_key="sk-APIsRouter-...",
)

TIER_MODELS = {
    "free": "mimo-v2.5",
    "standard": "deepseek-v4-pro",
    "premium": "claude-haiku-4-5",
    "top": "claude-sonnet-4-6",
}

MAX_REPLY_TOKENS = 250        # companion replies do not need essays
HISTORY_TOKEN_BUDGET = 2000   # summarize anything older instead of resending it

def companion_reply(user, prompt_messages):
    resp = client.chat.completions.create(
        model=TIER_MODELS[user.tier],
        messages=prompt_messages,  # card + memory + trimmed history + new message
        max_tokens=MAX_REPLY_TOKENS,
    )
    u = resp.usage
    record_spend(user.id, u.prompt_tokens, u.completion_tokens)  # your COGS ledger
    return resp.choices[0].message.content

FAQ