EDGE OSFREE TOOL · TOKEN COUNTER
Token counter for local LLMs
Paste a prompt or document to estimate its tokens for open-weight models like Llama, Qwen, DeepSeek, Gemma, GLM, Kimi and gpt-oss. See whether it fits each model’s context window and how much GPU memory it needs on your own hardware. Your text never leaves your browser.
496 characters
Llama 3.3 70B Instruct by Meta: 128K token context window, weights about 39 GB at INT4.
What does this mean?
Every open-weight model on this list has its own tokenizer, but modern ones with 128K to 262K-word vocabularies split ordinary English into a similar number of tokens. So the token estimate stays the same and the model you pick changes the context window, the memory each token needs and the hardware that can run it.
Learn more: Tokenization · Context window · Open-weight models
Each person working with a text this long needs their own KV cache on the GPU.
What does this mean?
While a model reads your text it keeps a working memory of every token, called the KV cache. It sits on the GPU next to the model weights, and every person using the model at the same moment needs their own. Long documents and many users are what push a deployment onto bigger hardware.
Learn more: KV cache · VRAM · Time to first token
125
Likely between 112 and 140 tokens for most open-weight models.
Characters
496
Words
80
Lines
8
Words per token
0.64
Fits, with about 130,947 tokens left for instructions and the answer.
Smallest fit: 1 NVIDIA H100 NVL.
KV cache from the model’s published architecture, stored at 16-bit. Includes about 5 to 10% runtime overhead. See Llama 3.3 70B Instruct VRAM needs →
Planning to run long documents through a local model? We will size the hardware with you.
Get a free sizing checkDoes it fit? Every local model at a glance
For your text (about 125 tokens) and 1 person. Memory includes the model weights at their lowest released precision.
| Model | Context | Share of context used | KV cache, 1 user | Memory, 1 person |
|---|---|---|---|---|
| Llama 3.3 70B Instruct Meta | 128K | <0.1% | 41 MB | 44 GB |
| gpt-oss-20b OpenAI | 128K | <0.1% | 13 MB | 15 GB |
| gpt-oss-120b OpenAI | 128K | <0.1% | 15 MB | 70 GB |
| Gemma 4 31B | 256K | <0.1% | 0.4 GB | 20 GB |
| Gemma 4 26B A4B | 256K | <0.1% | 0.2 GB | 16 GB |
| Qwen3.8-27B Qwen | 262K | <0.1% | 0.2 GB | 24 GB |
| Qwen3.6-27B Qwen | 262K | <0.1% | 0.2 GB | 20 GB |
| Qwen3.6-35B-A3B Qwen | 262K | <0.1% | 83 MB | 24 GB |
| DeepSeek-V4-Pro DeepSeek | 1M | <0.1% | 51 MB | 975 GB |
| DeepSeek-V4-Flash DeepSeek | 1M | <0.1% | 51 MB | 177 GB |
| DeepSeek-V3.2 DeepSeek | 128K | <0.1% | 10 MB | 418 GB |
| DeepSeek-R1 DeepSeek | 128K | <0.1% | 9 MB | 410 GB |
| GLM-5.3 Z.ai | 1M | <0.1% | 13 MB | 460 GB |
| GLM-5.3-Flash Z.ai | 1M | <0.1% | 0.1 GB | 192 GB |
| GLM-5.2 Z.ai | 1M | <0.1% | 13 MB | 454 GB |
| Kimi K3 Moonshot AI | 1M | <0.1% | 0.2 GB | 1.62 TB |
| Kimi K2.6 Moonshot AI | 256K | <0.1% | 9 MB | 626 GB |
| MiniMax-M3 MiniMax | 1M | <0.1% | 31 MB | 275 GB |
| MiMo-V2.5 Xiaomi | 1M | <0.1% | 0.1 GB | 190 GB |
How many tokens is that?
A token is a piece of a word that a language model reads and writes. Common words are one token; long or rare words, numbers and symbols are split into several. These rules of thumb hold for English with modern open-weight models:
1 token
About 4 characters of English, or three quarters of a word
100 tokens
About 75 words, a short paragraph
1,000 tokens
About 750 words, a page and a half of a report
8,000 tokens
About 6,000 words, a 12-page contract
128,000 tokens
About 96,000 words, a 250-page book
1,000,000 tokens
About 750,000 words, a large codebase or a shelf of manuals
Why some text uses more tokens
Tokenizers learn their vocabulary mostly from English web text, so other kinds of text are split into more, smaller pieces. That means more context used, more GPU memory and slower answers for the same amount of content.
Why token counts matter when you run AI on your own hardware
With a cloud API you pay per token. On your own hardware tokens are free, but they still decide three things: whether a document fits in the model’s context window, how much KV cache memory each user needs on the GPU, and how long the model takes before it starts answering (time to first token). A team summarizing 100-page contracts needs very different hardware from one answering short questions, even with the same model.
Use this counter on a few real documents your team works with, then put the length into our VRAM calculator to size the GPUs, or compare open-weight models side by side.
How this counter estimates tokens
The counter splits your text the way modern byte-pair-encoding tokenizers do: short common words count as one token, longer words as several, numbers in groups of up to three digits, punctuation and symbols mostly on their own, and other scripts at their own rates. It then shows a likely range rather than a single exact number. KV cache memory uses each model’s published architecture, or an estimate where the developer does not publish it, and model weights are counted at the lowest precision the model is released in. All figures are planning estimates.
FROM SIZING TO RUNNING
Sizing the hardware is the easy part.
Getting several GPUs to work as one system for a whole company is where most projects slow down. That is the part Vanik Edge OS does for you.
STEP 01 · THIS TOOL
Size it
Work out the GPU memory your models need and which GPUs or servers can hold them.
STEP 02 · VANIK EDGE OS
Cluster it
Edge OS joins your GPU servers into one cluster, splits a large model across them and keeps it running if a server fails. NVIDIA and AMD servers work side by side.
STEP 03 · VANIK EDGE OS
Run it
Your team gets AI apps with single sign-on and an audit trail, managed from one console, with your data staying inside your building.
Token counter questions
How do I count tokens for a local LLM?
Paste your text into the box above and pick the model you plan to run. The counter estimates the tokens, shows how much of that model’s context window they use and how much GPU memory that context needs. Everything runs in your browser.
How accurate is this token counter?
It is an estimate. It counts words, numbers, punctuation, line breaks and symbols the way modern tokenizers usually split them, and shows a likely range. For exact counts, run the model’s own tokenizer, for example with the Hugging Face tokenizers library or your inference server’s tokenize endpoint.
Do Llama, Qwen, DeepSeek and Gemma count tokens differently?
Yes, each has its own tokenizer, but for everyday English the totals are usually close because they all use large vocabularies of 128K words or more. Differences grow for code, numbers and non-English text. The bigger difference between models is the context window and how much memory each token takes.
How many tokens is 100 words?
About 130 tokens of ordinary English. A rule of thumb for modern models is 1 token for every 0.75 words, or about 4 characters. Short, common words are one token each; long words, numbers and punctuation add more.
How many tokens per word?
About 1.3 tokens per word for everyday English. Simple text can be closer to 1.1, while technical writing, code and text full of numbers or product codes can reach 2 or more.
How many tokens is 1,000 words?
About 1,300 tokens of ordinary English. Technical writing, code and numbers push that higher. JSON, spreadsheets and other structured data can need far more, because quotes, commas and IDs are often separate tokens.
How many words is 128K tokens?
About 96,000 words of English, roughly a 250-page book. That is the context window of Llama 3.3, gpt-oss and DeepSeek-V3.2, so a whole book-length document can fit in a single request.
How many words is 1 million tokens?
About 750,000 words of English, roughly 1,500 single-spaced pages or ten novels. Models with 1M-token context windows, such as DeepSeek-V4, GLM-5.3 and Kimi K3, can read that much at once, but the KV cache for it needs a lot of GPU memory.
What happens if my text is longer than the context window?
The model cannot read it all at once. You can split the document into chunks, summarize it in stages, or use retrieval-augmented generation (RAG) so the model only reads the passages it needs.
Why does a long prompt need more GPU memory?
While reading your text the model keeps a KV cache: a working memory of every token. It grows with the length of the text and with each person using the model at the same time, on top of the memory for the model weights.
Is my text sent anywhere?
No. The counting runs entirely in your browser and nothing you paste is uploaded or stored. That matters if you are testing with confidential documents, which is exactly why many teams run models on their own hardware.
Do local models charge per token?
No. When you run an open-weight model on your own hardware there is no per-token bill. Your costs are the hardware, power and people, which stay the same however many tokens you use.