200k Tokens In Costs 0.2 Times Your Input Rate

01 / A full 200k window is about 150,000 words before you type anything

Context window size is a capacity, not a price. The price appears the moment you fill that capacity. Most English text lands near 0.75 words per token, which puts a 200,000-token window at roughly 150,000 words, or around 300 double-spaced pages. That is three ordinary nonfiction books stacked into a single request.

The beginner mistake that quietly drains a small balance is this: the same prompt is re-sent on every turn. If turn one carries 200,000 tokens and you run ten turns without trimming anything, the model has read 2,000,000 input tokens, not 200,000. The window is a per-request ceiling. The bill is cumulative.

• ■ A whole repository pasted in one shot, often 100,000 to 300,000 tokens depending on the project.
• ■ A full PDF transcript or documentation set, easily 50,000 tokens on its own.
• ■ A conversation history replayed every turn, which is the silent multiplier.

02 / A full 200k prompt costs 0.2 times the listed input rate per call

The arithmetic is one line. Take the model input price in dollars per million tokens and call it R. A request carrying 200,000 tokens is 0.2 million tokens, so input alone costs 0.2 x R. If R were 1 dollar per million, that call is 20 cents. If R were 10 dollars per million, that call is 2 dollars. Those round numbers are worked examples, not quotes; read the live price for the model you pick before you spend.

Output tokens are billed separately and almost always at a higher rate. A 2,000-token answer is a small slice of the input cost when the prompt is huge, but on a tiny prompt it can dominate the receipt. Keep the two lines separate in your head.

Now multiply by your real week. Ten turns with a full, untrimmed history is 2,000,000 input tokens, which is 2 x R. Fifty short calls of 5,000 tokens each is 250,000 input tokens, which is 0.25 x R. Same week of work, eight times cheaper, because the second plan never paid to re-read the same context.

03 / Cache writes cost more than plain input and cache reads cost less

Prompt caching exists exactly for the repeated-prefix problem. You send a stable prefix once and pay a write charge for it. Later requests that reuse that identical prefix pay a read charge instead of the full input rate. Providers price the write as a multiple of base input and the read as a fraction of base input, and those two figures vary by model, so check the price card instead of guessing.

Caching only saves money when three conditions hold: the prefix is byte-identical across calls, the prefix is large, and you make many calls. A system prompt plus a fixed block of documentation plus a frozen file listing is a good cache block. Anything that rewrites the first 1,000 tokens on every request invalidates the cache, and you pay the write charge again.

CheapRelay bills per real token, cache reads and cache writes included, with no monthly fee and no subscription. A cached 200k prefix is therefore never free, it is cheaper on the second call and after. The receipt shows the split, so you can tell whether the cache is actually working for you.

04 / A working beginner session stays under 5,000 tokens per request

On a tiny budget the goal is to never approach 200k in the first place. Treat the window as emergency capacity, like a truck bed you pay for by the trip.

• ■ Start with a prompt under 2,000 tokens. Name the files and describe the shape of the problem rather than pasting the project.
• ■ Add one file at a time, and only the functions that matter. Ten lines of context beats ten thousand.
• ■ Every ten turns, request a 300-token summary of decisions, then open a fresh call where that summary is the entire history.
• ■ Put stable material first and the changing question last, so the cache prefix survives the edit.
• ■ Keep answers short. One 200-token reply costs far less than re-sending 150,000 words of context to get it.

The savings are not subtle. Fifty calls of 5,000 tokens is 250,000 input tokens. Ten calls of 200,000 tokens is 2,000,000 input tokens. At an example rate of 1 dollar per million, that is 25 cents against 2 dollars for the same week of tinkering. At 10 dollars per million, it is 2.50 dollars against 20 dollars.

05 / A seven-day ceiling of 5 dollars, with receipts to match

Budgets work only when they are enforced before the balance is gone. Split 5 dollars across seven days and you have about 71 cents per day. Convert that into tokens using your model rate, write the daily number down, and stop when you hit it.

For exploration, use a cheap model for the reading and summarising work, then spend the expensive calls only on the one question that needs them. Among the models currently on sale, a fast tier such as DeepSeek V4 Flash or Gemini 2.5 Flash handles the boring work well, leaving the rest of the budget for a single careful pass.

• ■ Read the usage block after every call and log input tokens, cache read tokens, cache write tokens, and output tokens.
• ■ Set a hard spend cap on the account rather than a reminder you can ignore.
• ■ Keep 20 percent of the weekly budget untouched for one well-prepared, expensive call.
• ■ Delete dead context instead of apologising for it in a follow-up message.
• ■ Multiply every planned call by 0.2 before you send it, so the 200k habit never sneaks back in.

The method is arithmetic plus discipline: a full window is 0.2 million tokens, the model re-reads that 0.2 million on every turn, and a live session belongs at 5,000 tokens instead. If you want to check these numbers against real receipts, sign up at CheapRelay and begin with a small amount of usage; it is pay as you go, billed per real token, and one key reaches the models above along with the rest of the catalog.