Skip to content

How many tokens is 1,000 words? What a token is and how to count them

Published 8 min read

For ordinary English prose, 1,000 tokens is roughly 750 words, so 1,000 words comes to about 1,300 to 1,350 tokens (around 1.3 tokens per word). Treat that as an estimate: the exact count depends on the model’s tokenizer, and code, numbers and non-English text usually take more tokens per word. For the real number, read the usage object the API returns with every response.

What is a token in an LLM?

A token is the unit a language model actually reads and writes. Before your prompt reaches the model, a tokenizer splits the text into pieces from a fixed vocabulary, and each piece maps to an integer id. Most modern tokenizers use some variant of byte-pair encoding: frequent character sequences get merged into single tokens, rare ones stay split into smaller pieces. A common English word like the or model is usually one token. A longer or rarer word like tokenization may be two or three. Punctuation, whitespace and line breaks are tokens too, or parts of tokens.

Everything about LLM APIs is measured in tokens: the context window (how much the model can see at once), the output limit (max_tokens), rate limits (tokens per minute), and price (dollars per million input and output tokens). Words are a human convenience; tokens are what you are billed for.

How many tokens is 1,000 words, a page, or a file of code?

The widely used rule of thumb for English is about 4 characters or 0.75 words per token. The table below applies that ratio to common units of text. The code rows are looser estimates because token counts for code swing more with language, naming style and indentation.

Estimates for English text using about 0.75 words per token. Real counts vary by tokenizer, language and formatting.
TextApproximate sizeApproximate tokens
1 short English word1 word1 to 2
A tweet-length message40 words50 to 60
A typical paragraph100 words130 to 140
A single-spaced page500 words650 to 700
A blog post1,000 words1,300 to 1,350
A long report10,000 words13,000 to 14,000
A novel-length manuscript100,000 words130,000 to 140,000
One line of source code1 lineroughly 7 to 15
A 300-line source file300 linesroughly 2,500 to 4,500

Two practical consequences. First, a prompt that "feels short" can still be thousands of tokens once you include a system prompt, retrieved documents and conversation history. Second, the same text costs a different number of tokens on different model families, so a price per million tokens is only comparable between models once you account for how efficiently each one tokenizes your actual content. The LLM API pricing guide covers that comparison in more detail.

Why do code and non-English text use more tokens?

Tokenizer vocabularies are built from training data, and the merges they learn reflect what was common in that data. Text that looks like the training mix compresses well into few tokens. Text that does not gets split into more, smaller pieces.

  • Other languages. Languages that were less represented when a tokenizer was built, or that use non-Latin scripts, often need noticeably more tokens for the same meaning than English. Newer tokenizers with larger vocabularies have narrowed the gap for many languages, but it has not disappeared. If you serve a multilingual product, measure on your own text rather than applying the English ratio.
  • Code. Identifiers like getUserAccountBalance split into several tokens, symbols and brackets are often their own tokens, and whitespace matters. Deep indentation, long generated names and minified code all inflate counts. Tokenizers trained with plenty of code handle common indentation runs efficiently; others do not.
  • Numbers, IDs and hashes. Long digit strings, UUIDs, base64 blobs and hex hashes tokenize poorly because they are close to random. A JSON payload full of IDs can cost far more tokens than its character count suggests.
  • Structured data. JSON keys repeated on every row of an array add up. Sending the same data as a compact table or CSV-like text is often cheaper in tokens, though you should check that the model still reads it reliably.

What else counts as tokens besides your message?

The input bill covers everything the model has to read on that call, not just the latest user message. On chat APIs that includes:

  • System prompts. Sent and billed on every request. A 2,000-token system prompt on a 50-token question means you pay for over 2,000 input tokens each time.
  • Conversation history. Chat APIs are stateless, so each turn resends earlier turns. Input tokens per request grow as the conversation grows, which is why long agent sessions get expensive.
  • Tool and function definitions. The JSON schemas for your tools are serialized into the prompt. A large tool catalog can add thousands of tokens to every call, used or not.
  • Images and other media. Vision models convert images into tokens too. The count depends on the provider’s method, the image resolution and any detail setting, so the same picture can cost very different amounts on different models.
  • Reasoning tokens. Reasoning models generate internal thinking before the visible answer. Those tokens are typically billed as output and draw from the same max_tokens allowance as the answer, so a tight limit can truncate the reply.
  • Formatting overhead. Role markers and message separators add a handful of tokens per message.

How do I count tokens exactly?

There are two reliable ways, and one of them is free.

  1. Read usage from the response. OpenAI-compatible APIs return a usage object with prompt_tokens (input), completion_tokens (output) and total_tokens. This is the count the provider actually billed against, including system prompts, tools and media, so it is the number to log and to reconcile with your invoice.
  2. Use the model maker’s tokenizer offline. For estimating before you send, a tokenizer library for that model family gives exact counts for plain text. It only matches models that use that same tokenizer, and it will not include the per-message formatting overhead or image tokens, so expect it to slightly undercount a full chat request.

The snippet below sends a request through an OpenAI-compatible client and reads the token counts back. It works against Smouter by pointing the client at https://api.smouter.ai/v1; copy a live model id from the models page.

python
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.smouter.ai/v1",
    api_key=os.environ["SMOUTER_API_KEY"],
)

resp = client.chat.completions.create(
    model="<model-id>",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain what a token is in two sentences."},
    ],
)

u = resp.usage
print("input tokens: ", u.prompt_tokens)
print("output tokens:", u.completion_tokens)
print("total tokens: ", u.total_tokens)

# Some models also report a breakdown, for example reasoning or cached tokens.
details = getattr(u, "completion_tokens_details", None)
if details is not None:
    print("reasoning tokens:", getattr(details, "reasoning_tokens", None))

For streaming responses, the usage numbers arrive at the end of the stream rather than in each chunk, and the final charge is settled after the stream finishes. On Smouter, the Usage page lists tokens and cost per request, and understanding your usage walks through reading it.

How do tokens turn into cost?

Chat models are priced per million tokens, with separate rates for input and output. Output is almost always the more expensive side, often by a multiple. The formula for one request is simple:

text
cost = (input_tokens  / 1,000,000) * input_price_per_million
     + (output_tokens / 1,000,000) * output_price_per_million

Take a 1,000-word document you want summarized in 200 words. Input is about 1,350 tokens plus your instructions, output about 270 tokens. At a hypothetical $1 per million input and $4 per million output, that is roughly $0.00135 plus $0.00108, about a quarter of a cent. Multiply by your request volume and the levers become obvious: input size dominates for retrieval and long-context work, output size dominates for generation, and reasoning tokens can quietly multiply output.

A few refinements change the math in practice. Many providers bill repeated prompt prefixes at a discounted cached-input rate. Reasoning tokens count as output. Images and audio may be billed per token, per image or per second depending on the model. The pricing explainer breaks down each of these, and how to reduce LLM API costs covers the practical ways to shrink both sides.

Tokens and rate limits

Tokens also govern throughput. Tokens-per-minute (TPM) limits cap how much input and output you can push through in a rolling minute. On Smouter, per-key and per-organization TPM caps apply to chat completions, Messages, Responses and embeddings, and a rejection returns 429 with a retry-after header. The rate limits article covers the details. When you estimate capacity for a batch job or an agent fleet, estimate in tokens, not requests.

Practical ways to spend fewer tokens

  • Keep system prompts and tool schemas lean, and only include tools the current step can use.
  • Summarize or truncate old conversation turns instead of resending the full history forever.
  • Retrieve fewer, better chunks rather than stuffing the context window.
  • Set max_tokens to a sensible ceiling for the task, leaving room for reasoning on reasoning models. You pay for tokens generated, not for the ceiling you set.
  • Ask for compact output formats when the answer feeds code, not a human.
  • For coding agents, which resend large file contexts on every step, watch per-session token totals. The AI coding agents cost guide shows where those tokens go.

The other half of the equation is the price per token. The same open-weight model, for example DeepSeek V4, can be served by several providers at different rates. Smouter shops each request across a benchmarked pool of providers serving the same model weights, so the token count stays the same while the rate is bought at the floor; live per-lane prices are on the models page, and the API is documented in the docs.

Frequently asked questions

How many tokens is 1,000 words?

For English prose, about 1,300 to 1,350 tokens, based on the common rule of thumb of 0.75 words per token. The exact figure depends on the model’s tokenizer and on the text itself. Technical vocabulary, code, numbers and non-English languages usually push the count higher. Read the usage object in the API response for the precise number.

How many words is 1,000 tokens?

Roughly 750 English words, or about 4,000 characters. That is a little over one and a half single-spaced pages. For code, other languages or text full of numbers and IDs, 1,000 tokens covers less content, so test with your own data before planning around the English ratio.

Are input tokens and output tokens priced the same?

Usually not. Most providers charge more for output tokens than input tokens, often by a multiple, because generating tokens is more expensive than reading them. Some also offer a lower rate for cached input, meaning a repeated prompt prefix. Reasoning tokens on thinking models are typically billed at the output rate.

Does the system prompt count toward tokens?

Yes. The system prompt is part of the input on every request and is billed each time. Tool definitions, earlier conversation turns and images count as input too. A long system prompt on a short question can make up most of the input bill, which is why keeping it lean, or stable enough for prefix caching, matters.

Do different models count tokens differently?

Yes. Each model family ships its own tokenizer with its own vocabulary, so the same text can produce different token counts on different models. That means per-million-token prices are only directly comparable once you account for how efficiently each model tokenizes your actual content.

How can I count tokens before sending a request?

Use a tokenizer library published for that model family to count plain text offline. It gives exact counts for text but usually misses per-message formatting overhead, tool schemas and image tokens, so expect a small undercount on full chat requests. For billing-grade numbers, log usage.prompt_tokens and usage.completion_tokens from real responses.