How to Cut Your AI Token Costs by 65% with Clean Input

If you use the ChatGPT or Claude API for any kind of web content processing, you are almost certainly paying for tokens you do not need. Navigation bars, ad scripts, tracking pixels, inline CSS, and invisible metadata all get tokenized and billed, even though they contribute nothing to the AI's understanding of the page.

This guide breaks down exactly how token waste happens and what you can do to eliminate it.

What Are Tokens and Why Do They Cost Money?

Tokens are the atomic units that large language models use to read and generate text. A token is roughly four characters in English, or about three-quarters of a word. Every API call is billed by token count, both for the input you send and the output you receive.

Here is how pricing works with popular models (as of early 2026):

• GPT-4o: $2.50 per 1M input tokens / $10 per 1M output tokens (see OpenAI API pricing)
• Claude Sonnet: $3 per 1M input tokens / $15 per 1M output tokens (see Anthropic Claude pricing)
• GPT-4 Turbo: $10 per 1M input tokens / $30 per 1M output tokens

When your input is bloated with HTML junk, you pay for every single wasted token. At scale, this adds up fast.

How Raw HTML Wastes Your Tokens

Consider a typical news article. The actual content might be 800 words, roughly 1,100 tokens. But if you send the raw HTML of that page, here is what actually gets tokenized:

Raw HTML source:          ~18,400 tokens
├── Navigation/header:      2,100 tokens
├── CSS/style tags:         3,800 tokens
├── JavaScript:             4,200 tokens
├── Ad containers:          1,900 tokens
├── Footer/sidebar:         1,600 tokens
├── Schema/meta tags:       1,200 tokens
├── Tracking scripts:         900 tokens
├── Actual content:         1,100 tokens
└── Other markup:           1,600 tokens

That means only 6% of the tokens you are paying for carry useful information. The other 94% is noise.

Before and After: A Real Example

We tested this with a 1,500-word technical blog post. Here are the actual token counts:

| Input Method | Token Count | Cost (GPT-4o) | Useful Content | |---|---|---|---| | Raw HTML | 16,820 | $0.0421 | ~6% | | Copy-paste from browser | 3,450 | $0.0086 | ~35% | | Cleaned Markdown (Web2MD) | 1,890 | $0.0047 | ~92% |

The cleaned Markdown version uses 89% fewer tokens than raw HTML, and 45% fewer than a naive copy-paste. Even browser copy-paste carries hidden formatting characters, extra whitespace, and broken structure that inflate token counts.

Five Strategies to Reduce Token Waste

1. Strip HTML Before Sending to the API

Never send raw HTML to a language model. At minimum, remove all <script>, <style>, <nav>, and <footer> tags before processing. A basic Python approach:

from bs4 import BeautifulSoup

def clean_html(raw_html):
    soup = BeautifulSoup(raw_html, 'html.parser')
    for tag in soup(['script', 'style', 'nav', 'footer', 'header']):
        tag.decompose()
    return soup.get_text(separator='\n', strip=True)

This helps, but still leaves you with unstructured plain text that lacks headings, lists, and other context the AI benefits from.

2. Convert to Markdown for Structure + Brevity

Markdown is the sweet spot between raw text and formatted HTML. It preserves document structure (headings, lists, tables, code blocks) while being extremely token-efficient — following the lightweight syntax defined by the CommonMark specification. Language models understand Markdown natively since a large portion of their training data is in this format. Our Markdown vs HTML comparison breaks down exactly why this matters for response quality, not just cost.

3. Use Web2MD for Automated Cleaning

Rather than building custom scraping pipelines, Web2MD handles the entire conversion in one step. The browser extension extracts the main content from any webpage, strips all the noise, and outputs clean Markdown that is ready for AI consumption. It also shows you the estimated token count before you paste.

4. Trim Redundant Sections

Even after cleaning, you might not need the entire page. If you only care about the methodology section of a research paper, send only that section. Targeted extraction can cut your tokens by another 50-80% on top of cleaning.

5. Batch and Deduplicate

When processing multiple pages from the same site, strip repeated elements like author bios, related article lists, and boilerplate disclaimers. Combine unique content and summarize when possible.

Cost Savings at Scale

Here is where the numbers get serious. Consider a workflow that processes 500 web pages per day through the GPT-4o API:

| Scenario | Tokens/Page | Daily Tokens | Monthly Cost | Annual Cost | |---|---|---|---|---| | Raw HTML | 16,000 | 8,000,000 | $600 | $7,200 | | Basic cleaning | 6,000 | 3,000,000 | $225 | $2,700 | | Markdown (Web2MD) | 2,000 | 1,000,000 | $75 | $900 |

Switching from raw HTML to clean Markdown saves $6,300 per year on a single workflow. That is a 87.5% reduction in costs.

Even at smaller scale, processing 50 pages per day saves over $600 annually.

Tips for API Power Users

If you are building applications that consume web content through AI APIs, these practices will compound your savings:

1. Cache converted content. If the same page is analyzed multiple times, convert to Markdown once and reuse.
2. Set max token limits. Use the max_tokens parameter to cap output length and prevent runaway costs.
3. Use token counting before sending. Libraries like tiktoken for OpenAI or Web2MD's built-in counter let you preview costs.
4. Implement progressive extraction. Send a summary first; only send full content if the AI needs more context.
5. Choose the right model. Not every task needs GPT-4. Use GPT-4o-mini or Claude Haiku for simpler extraction tasks at a fraction of the cost. Compare the full model lineup on the OpenAI pricing page and the Anthropic pricing page to find the best fit for each task.

You can use OpenAI's open-source tiktoken library to count tokens programmatically before making API calls:

import tiktoken

def estimate_cost(text, model="gpt-4o"):
    enc = tiktoken.encoding_for_model(model)
    tokens = len(enc.encode(text))
    cost = tokens * 2.50 / 1_000_000  # input cost
    return tokens, cost

# Compare raw vs clean
raw_tokens, raw_cost = estimate_cost(raw_html)
clean_tokens, clean_cost = estimate_cost(markdown_text)
print(f"Savings: {(1 - clean_cost/raw_cost)*100:.0f}%")

Batch Optimization for Research Workflows

When conducting research across many pages, the token savings multiply. Here is an effective batch workflow:

1. Collect URLs for all target pages
2. Convert each page to Markdown using Web2MD or a programmatic approach
3. Deduplicate common boilerplate across pages from the same domain
4. Chunk intelligently by section rather than by arbitrary character limits
5. Summarize first, deep-dive later to minimize total tokens across your session

This approach typically brings the per-page effective cost down to 20-35% of what most teams are currently spending. Web2MD v0.4.0 added batch conversion that makes this workflow even faster.

Conclusion

Token costs are one of the most controllable expenses in any AI workflow. The single highest-impact change you can make is cleaning your input before it reaches the API. Converting raw HTML to structured Markdown routinely cuts token usage by 65-90%, with zero loss of useful information.

The math is simple: cleaner input means fewer tokens, lower costs, and often better AI output since the model can focus on actual content instead of parsing through noise. For a step-by-step conversion guide, see how to convert any webpage to Markdown.

---

Stop overpaying for AI tokens. Try Web2MD — convert messy web pages to clean Markdown and cut your token costs by up to 65%.