Cost Per Email Processed by AI: A Working Estimate

Cost per email processed by AI sounds like it should be a single number, and vendors often quote one: a flat monthly price, or a pool of credits that drains as you use the product. Neither tells you what the underlying AI spend actually is. Triage, summarization and draft-writing are three different jobs with three different token profiles, and pricing them as if they cost the same hides where the money actually goes.

This post builds the number from scratch, using published API list prices rather than a vendor's internal cost or a marketing claim. The method is simple enough to redo with your own email volume: estimate the tokens per action, price each action at the model tier it actually needs, then multiply by how many emails you process in a day. As of August 2026, the answer is well under a cent per email — until one step gets routed to the wrong model.

The short answer#

For a typical business email — roughly 300 words, no attachments — running triage on a small/fast model, summarizing on a mid-tier model, and drafting a routine reply on that same mid-tier model costs about $0.001 per email: a tenth of a cent. At 120 emails a day, that's roughly $3.60 a month in raw model spend.

The number moves a lot if the draft step gets escalated to a frontier-class model instead, which some pipelines do by default for every reply regardless of how routine it is. That single change roughly quadruples the total, to about $0.004 per email and $13.70 a month at the same volume. The gap isn't in triage or summarization — both stay cheap under either policy. It's entirely in which model writes the draft.

Criteria that actually matter#

Five things decide what an email-processing pipeline actually costs, and none of them is the sticker price of the best available model. Get these right and the numbers above hold up; miss one and the real bill can be off by an order of magnitude.

This matters beyond curiosity, because it's the same list a vendor's engineering team works through when they price a plan. A plan that ignores one of these five is either quietly losing money on heavy users or quietly overcharging light ones — and either way, it's the reader footing the difference.

• Which action the tokens are for. Draft-writing produces far more output than triage or summarization, and output tokens are priced several times higher than input tokens on every major vendor's rate card — so replying to an email costs more than filing it.
• Which model tier handles each action. A small/fast model and a frontier model can differ 5–25x in price for input and output alike. Sorting an email into one of six labels rarely needs frontier-level reasoning, and a routine acknowledgment reply often doesn't either.
• How much context rides along on every call. Thread history, an attachment converted to text, and a voice or context profile all add input tokens on top of the email itself. A 400-token email with an 800-token context block is mostly billed for the context, not the message.
• Whether the vendor discloses real usage or abstracts it into credits. A credit system that doesn't publish its token-to-credit ratio makes this whole exercise impossible to check from the outside.
• Whether repeated context gets cached. Most vendors discount input tokens that repeat verbatim across calls — a system prompt, a signature block, a context profile — often steeply. A pipeline that resends the same tokens raw on every email is paying full price for nothing new.

Three ways to route the work#

Given those criteria, there are really only three routing policies a pipeline can run, and they score very differently on cost, quality risk, and how much work they are to set up.

A worked example: 50, 120 and 300 emails a day#

Here's the method laid out with real numbers, so it can be reproduced with different token counts. Assume a typical email body of about 300 words (~400 tokens), priced against OpenAI's published API rates as of August 2026: GPT-5 nano at $0.05 / $0.40 per million tokens (input / output), GPT-5 mini at $0.25 / $2.00, and full GPT-5 at $1.25 / $10.00.

Two of these numbers move in opposite directions with more context: a longer email or a longer thread raises input tokens for every action, while a terser house style for drafts lowers output tokens for that one step. Swap in the actual average email length and reply length for a given inbox and the ratios below hold even if the absolute figures shift.

Add triage, summary and a routine draft together and one email costs about $0.001 to process end to end. Swap only the draft step for the frontier model and the total rises to about $0.004 — draft-writing alone accounts for roughly 90% of the bill either way, because it's the only step producing real conversational output rather than a label or a short summary.

Multiply the per-email number by a day's volume and it stays a rounding error at every realistic scale.

Red flags in a usage-based bill#

Once you know roughly what these three actions should cost, a usage-based bill either confirms the estimate or gives you something concrete to ask a vendor about. Other model vendors publish comparable ladders for their own small/fast tiers — Google's and Anthropic's fast models sit roughly 5–10x below their respective frontier models, the same shape as OpenAI's, even though the absolute numbers differ — so a bill that doesn't reflect any tiering at all is worth a second look.

• Ask for the token-to-credit conversion rate, in writing.
• Check whether a summary and a draft cost the same credits — they shouldn't.
• Compare your monthly credit spend against the worked-example numbers above at your own volume; a gap of 3–5x is margin and infrastructure, a gap of 20x or more is worth a direct question.
• Check whether the plan lets triage run on a cheap model while reserving a better one for drafts, or forces every action through the same tier — the second design pays frontier prices for work a nano-tier model handles just as well.

What we'd pick, and who shouldn't#

If you're comfortable wiring a router yourself — deciding what counts as complex per email, calling the right model tier per action, and reconciling the bill against a table like the one above — a direct API integration will always be the cheapest way to do this, full stop. That's not a knock on packaged tools; it's what happens when the client, the sync engine and the support desk that most people are also paying for get cut out.

For everyone else, we build AI Emaily, and it's built around the same tiered idea rather than one model for everything: triage, summarization and drafting each draw from a plan's AI credits at a rate scaled to what the action actually costs, not a flat per-message fee. Copilot mode holds every draft for approval before it sends, with an undo and an audit trail, across Gmail, Outlook and IMAP accounts — and voice matching comes from a Context brain and per-client profiles set up by the user, not a model trained on anyone's mail. There's no permanent free tier; Pro and Autopilot start with a 7-day free trial, card required, $0 if cancelled before day 7.

The honest limit: if all that's needed is raw email classification at the lowest possible per-message cost, with no client at all, wiring a nano-tier model directly (or routing through OpenRouter) will always undercut any packaged product's price, ours included. What a client buys is not having to build that router, keep it running as vendors change their rate cards, and reconcile the bill against the kind of table this post just walked through.