Prompt Weight Analyzer
Most production prompts carry weight the model never needed: the same instruction written twice, raw HTML that should have been Markdown, a paragraph of politeness, three blank lines where one would do. On the three samples measured below that overhead runs 27.9%–53.5% of input tokens — and because it is input, it is billed on every single request. Paste a prompt and see where yours goes.
Weigh your prompt, category by category
Runs entirely in your browser. Five rule-based checks run in a fixed order, and each reports the tokens it would remove on its own — so the rows add up to the total.
| Category | Tokens | Share of prompt | Verdict |
|---|
| Model | As written / 1,000 requests | Trimmed / 1,000 requests | Saved / 1,000 requests | Saved / 100,000 requests |
|---|
Three prompts, before and after
Token counts from this site's estimator on the sample prompts loaded by the buttons above. "Flagged" is every category the analyzer would remove, combined.
| Sample prompt | Characters | Tokens now | After trim | Flagged | Largest category |
|---|---|---|---|---|---|
Support system prompt Duplicated rules, JSON schema, courtesy preamble | 1,412 | 312 | 216 | 96 tokens · 30.8% | Repeated sentences (48) |
RAG prompt with HTMLWorst Retrieved passages pasted as raw markup | 770 | 187 | 87 | 100 tokens · 53.5% | Markup tags (48) |
Few-shot classifier Repeated example pairs, one courtesy line | 767 | 172 | 124 | 48 tokens · 27.9% | Repeated lines (30) |
The largest single category differs on every sample, which is the point: there is no universal prompt bloat. Duplicate content dominates when instructions get copy-pasted, markup dominates when a retriever hands back raw HTML, and neither matters on a lean prompt. Run your own before assuming which one applies to you. Counts come from the heuristic estimator used across this site, not a provider tokenizer.
What each check actually removes
Five rules, no model calls, no guessing. Each one is a deterministic text transform, so the reported saving is the measured difference, not an estimate on top of an estimate.
| Check | What it targets | Verdict | On the samples |
|---|---|---|---|
Excess whitespace Runs of spaces and tabs, trailing spaces, blank-line piles | Collapses every run to one space and caps blank lines at two | Remove | 0 – 2 tokens |
Repeated sentences Identical sentences of 25+ characters | Keeps the first occurrence, drops every later one | Remove | 15 – 48 tokens |
Repeated lines Identical whole lines of 20+ characters | Keeps the first occurrence, drops every later one | Remove | 18 – 31 tokens |
Markup tags HTML or XML tags, when three or more are present | Strips the tags and leaves the text | Convert | 48 tokens (RAG sample only) |
Politeness & hedging Courtesy preamble and hedging boilerplate | Removes phrases such as "please", "make sure to" and "keep in mind that" | Review | 1 – 28 tokens |
Rules are applied in the order shown and each reports its own marginal effect, so a sentence already removed by an earlier check is never counted twice. "Apply safe cleanups" only runs the two removals that cannot change meaning — whitespace and repeated lines — and leaves markup and politeness for you to decide.
Weight is billed per request, not per prompt.
A single bloated prompt is cheap. The same prompt sent ten thousand times a day is a line item. This is the part that catches teams out: the prompt is written once, reviewed once, and then paid for forever.
Duplication is usually an accident. Instructions get copy-pasted between environments, a rule is restated in both the system prompt and the user turn, and a few-shot example is duplicated by a bad merge. Nothing is wrong functionally, so nobody notices — the tokens just keep billing.
Markup is billed at prose rates. Every <div class="..."> and </h2> costs the same per token as a sentence of the document. On the RAG sample, 48 of 187 input tokens were pure markup.
And the saving scales with the model. On the default support sample, the 96 flagged tokens are worth $0.38 per 1,000 requests on GPT-5.6 Sol and $0.48 on Claude Opus 5 — same tokens, more money, because the percentage applies to a higher rate. At 10,000 requests a day that is $1,752 a year on Opus 5 for text the model never needed.
What one repeated block costs per year
The arithmetic that makes prompt weight worth measuring: block size × requests per day × 365, priced at published per-1M input rates. Nothing here involves output tokens.
| Repeated block | 1,000 req/day · Sonnet 5 | 10,000 req/day · Sonnet 5 | 10,000 req/day · Opus 5 |
|---|---|---|---|
10 tokensOne clause "Answer in English." | $7.30 | $73.00 | $182.50 |
60 tokens One duplicated rule | $43.80 | $438.00 | $1,095.00 |
200 tokens A restated policy paragraph | $146.00 | $1,460.00 | $3,650.00 |
500 tokens An uncached system prompt | $365.00 | $3,650.00 | $9,125.00 |
Computed as tokens × requests/day × 365 ÷ 1,000,000 × rate, at Claude Sonnet 5 ($2.00 per 1M input) and Claude Opus 5 ($5.00 per 1M input), verified 2026-08-09 to 2026-08-16. These are input tokens only and exclude caching, batch and taxes. Note the middle column: the same 500-token block costs $3,650 a year on Sonnet 5 and $9,125 on Opus 5 — which is why trimming matters most on the expensive model, even though the percentage saved is identical.
When you should leave the weight in
Not every flagged token is a wasted token. Three cases where trimming is the wrong call.
Politeness can be load-bearing. Removing "please" and "keep in mind that" measurably shifts tone on customer-facing output. Those tokens are flagged Review, not Remove, for exactly this reason — 28 tokens on the support sample is $0.14 per 1,000 requests on Opus 5, which is a fair price for a reply that does not read like a machine.
Duplicates are sometimes deliberate. Restating a constraint at the end of a long prompt genuinely improves adherence, because attention is not uniform across the context. If you removed a duplicate and quality dropped, put it back — the analyzer is reporting cost, not correctness.
Markup may be the subject. If the task is about DOM structure, class names or link targets, stripping the tags destroys the answer. Send a cleaned copy for extraction tasks and keep the markup for structural ones. For a dedicated measurement of that trade-off, use the HTML Token Savings calculator.
Prompt weight questions
How much of a typical prompt is avoidable weight?
On the three sample prompts measured with this site's estimator, 27.9% to 53.5% of input tokens were avoidable: 30.8% on a duplicated customer-support system prompt, 53.5% on a RAG prompt carrying raw HTML passages, and 27.9% on a few-shot classifier with repeated examples. The single largest category differed each time — repeated sentences, markup tags and repeated lines respectively.
Does trimming a prompt change the model's answer?
Removing exact duplicates and markup should not, which is why those categories are marked Remove or Convert. Politeness and hedging phrases are marked Review instead, because deleting them can shift tone. Whitespace removal is marked Remove but moves the fewest tokens of any category.
How much does one repeated instruction actually cost?
A 60-token repeated block sent 10,000 times a day costs $438 per year on Claude Sonnet 5 at $2.00 per million input tokens, and $1,095 per year on Claude Opus 5 at $5.00. A 500-token system prompt you forgot to cache costs $3,650 and $9,125 respectively at the same volume.
Is whitespace worth trimming?
It is the smallest lever. This site's estimator weights a space or newline at 0.08 tokens against roughly 0.25 for a Latin letter, so collapsing runs of whitespace saved 0 to 2 tokens on the three sample prompts. Production tokenizers sometimes bill each space separately, so real savings may be somewhat larger — but repeated instructions and markup are where the weight actually is.
Does this tool upload my prompt?
No. The analysis and the token estimate run entirely in your browser. This page has no form, no backend endpoint, no analytics script and no network requests — paste a proprietary system prompt without it leaving the tab.
How these numbers are produced.
Five deterministic text transforms run in a fixed order — collapse whitespace, drop repeated sentences, drop repeated lines, strip markup tags, remove politeness boilerplate — and each reports the token difference it produced on its own. Because the transforms are applied cumulatively and each measures its own marginal effect, the category rows sum exactly to the flagged total, and no token is counted twice. The politeness list is a fixed set of 26 common English courtesy and hedging phrases; it is English-only and will find nothing in a prompt written in another language.
Token counts come from the same heuristic estimator used across this site, which weights CJK characters, emoji, punctuation, whitespace and Latin characters separately — a cross-model approximation, not provider tokenizer output, so real counts differ by a few percent. Cost figures multiply token counts by published per-1M input rates, with OpenAI's long-context surcharge applied automatically above 272,000 input tokens. Output tokens are unaffected by trimming and are excluded. Caching, batch, tool use and taxes are excluded throughout. Rates: OpenAI, Anthropic, Google — verified weekly.