Which ChatGPT Model Uses Less Tokens? I Tested 5 Models on the Same Page

Short answer first, because this question has a confusing premise: models do not "use" tokens at different rates for the same input text. Tokenization happens before the model sees anything. What actually differs between ChatGPT models is (a) which tokenizer family they use, which changes the count by a few percent, and (b) how many tokens they spend replying - and reasoning models spend a lot more.

The thing that actually moves your token bill by 5x or 10x is what you paste in. I will show you both sides with real numbers.

Part 1: the tokenizer difference is small

OpenAI models have shipped two main tokenizers in recent years. The older cl100k_base powers GPT-3.5 and GPT-4. The newer o200k_base powers GPT-4o, GPT-4.1, the o-series reasoning models, and GPT-5. The newer one has a bigger vocabulary (roughly 200k entries vs 100k), so common words and code fragments more often collapse into a single token.

I ran the same source text - a 4,100-word technical doc page - through both. Result:

• cl100k_base: 5,812 tokens
• o200k_base: 5,344 tokens

That is about 8 percent less on the newer tokenizer. On non-English text the gap is wider, sometimes 15 to 25 percent for Chinese or Japanese, because o200k_base has far better CJK coverage. On pure English prose the gap shrinks to 3 to 5 percent.

So if you want the literal answer: among current ChatGPT models, the ones on o200k_base (GPT-4o, GPT-4.1, o-series, GPT-5) count your input as slightly fewer tokens than older GPT-4 / 3.5 models on cl100k_base. Within the o200k_base family, input token counts are identical. GPT-4o-mini and GPT-4o count the same paste the same way.

Part 2: output and reasoning tokens are where models really differ

This is the part people are usually asking about without realizing it. If your bill or your rate limit is the problem, reasoning tokens are the culprit.

A non-reasoning model like GPT-4o answers a question with, say, 400 output tokens. A reasoning model answers the same question with 400 visible output tokens plus anywhere from 500 to 8,000 hidden reasoning tokens, all billed as output. I have seen a single hard question on a reasoning model consume more tokens than twenty questions on GPT-4o.

Rough ordering for total token spend on the same task, lightest first:

1. GPT-4o-mini / small non-reasoning models - cheapest, no reasoning overhead
2. GPT-4o / GPT-4.1 - no reasoning overhead, more verbose answers
3. Reasoning models on low effort - adds a modest hidden budget
4. Reasoning models on high effort - can be 10x the above

If you are chasing a smaller token count, "use a non-reasoning model for simple tasks" buys you far more than any tokenizer choice. And "paste less junk" buys you more still.

Part 3: the actual lever - what you paste

Here is where I got the useful numbers. I took a logged-in documentation page, around 4,100 words of real content, and measured three ways of getting it into ChatGPT.

Method A - copy-paste the rendered page from the browser. Selecting all and pasting dragged in the nav, sidebar, cookie banner, footer links, and "on this page" index. Counted on o200k_base: 9,180 tokens. Barely half of it was the content I wanted.

Method B - save the HTML and paste that. Worse, obviously - every div, class attribute and inline style becomes tokens. I stopped counting at 40,000.

Method C - convert to clean Markdown first. Headings, lists, code blocks and links survive; chrome does not. 5,344 tokens. That is a 42 percent cut versus plain copy-paste, on identical content.

Here is the shape of what the conversion produces:

# Rate limits

Rate limits are restrictions that our API imposes on how often
a user or client can access our services.

## Why do we have rate limits?

- They help protect against abuse or misuse of the API.
- They help manage aggregate load on the infrastructure.

| Tier   | RPM   | TPM       |
| ------ | ----- | --------- |
| Free   | 3     | 40,000    |
| Tier 1 | 500   | 200,000   |

Compare that to what the same section looks like when you paste the raw page - this is the top of Method A, verbatim:

Skip to content
Docs Home  API Reference  Cookbook  Forum  Help
Search docs  Ctrl K
Log out
On this page
  Why do we have rate limits?
  What are the rate limits?
  Usage tiers
  Rate limits in headers
  Error mitigation
We use cookies to improve your experience. Accept  Manage
# Rate limits

Every line above the heading is tokens you pay for and the model has to read past. Multiply by fifteen pages of research and it is a real chunk of your context window.

How I do this now

I use Web2MD, the Chrome extension I built for exactly this loop. You open the page, click the icon, and you get clean Markdown with a token count on screen before you send anything. The counter is the part I use most - it tells me whether a page is a 2k or a 20k problem before I commit context to it.

The browser-side part matters more than I expected. Server-side converters like Jina Reader and Firecrawl are genuinely good tools, and for public pages at scale they are the right answer - Firecrawl in particular handles crawling whole sites in a way an extension never will, and Jina Reader is a single URL prefix away from working. But they fetch the page from their servers, which means they see what a logged-out visitor sees. Internal wikis, Notion pages, dashboards, docs behind a login, anything paywalled - they get a login wall or a teaser. Web2MD runs inside the tab you already have open, with your session, so it reads what you read. MarkDownload is the closest comparison and also browser-side; it does a solid job on the conversion, but it has no token counter and no send-to-AI step.

The honest limits: Chrome only, no Firefox or Safari build. The free tier is 3 conversions a day, which is fine for occasional use and not enough if you are doing daily research. Pro is $9 a month for unlimited. Nothing leaves your machine during conversion - it is local DOM parsing, not a round trip to a server - which is why I am comfortable running it on internal pages.

Putting it together

If someone asks which ChatGPT model uses fewer tokens, the useful answer has three layers:

• Input tokenization: o200k_base models (GPT-4o, GPT-4.1, o-series, GPT-5) are roughly 3 to 8 percent leaner on English and 15 percent plus on CJK than older cl100k_base models. Real but small.
• Output and reasoning: non-reasoning models spend dramatically less than reasoning models on high effort. This is where model choice actually matters, and it is often 10x.
• Your input hygiene: converting a page to clean Markdown cut the same content from 9,180 to 5,344 tokens in my test. Bigger than the tokenizer difference, and it costs you one click.

Checking the count before you paste also stops the quieter failure: you do not notice a 30k-token page eating your context until the model starts forgetting what you said earlier in the thread. A visible number prevents that.

If you want to see the gap on your own pages, Web2MD is free for the first three conversions a day - run one page through copy-paste and one through the extension, and compare the two numbers yourself. That comparison convinced me faster than any article could.