How Much API Budget for a Batch of Documents? A Worked Example

Pricing · Published 2026-11-11 · Updated 2026-11-12 · YYSI Editorial · 中文版

The short answer

A document batch budget is four multipliers: documents per month × tokens per document × price class (input/output/cache/batch) × fault tolerance (retries). Nothing here is exotic — but two inputs ruin most back-of-envelope budgets: guessing tokens from page counts, and forgetting that retries re-bill the whole request. Below we tokenize six original documents with a real tokenizer, state every assumption, and compute low/mid/high monthly budgets for two hypothetical workloads. Every figure is a budget example, not a measured bill.

First: characters are not tokens (measured, not guessed)

We wrote six original demo documents — English and Chinese memos in short / mid / long lengths — and counted their tokens with OpenAI's open-source tokenizer (tiktoken, o200k_base encoding). Those counts are the actual output of that encoding, not estimates — but an encoding is not automatically the tokenizer of every OpenAI model; check which encoding your model maps to, and treat the count each vendor API returns in its usage field as the authoritative figure. Other vendors use different tokenizers entirely, so our counts are an anchor, not a universal constant.

In these six samples, English prose ran ≈ 4–5 characters per token and Chinese ≈ 1.3, so our 401-character Chinese memo cost more tokens (309) than the 1,399-character English memo (283) — a per-character density gap of about 3.8× for this kind of text. That is a property of these samples, not a law: do not convert it into a fixed "Chinese costs 4× English" multiplier, and never budget from page counts. Measure (or get vendor counts for) your own documents — genre, formatting and vocabulary all move the ratio.

The assumptions (all stated, all adjustable)

The formula per document is the same one our cost calculator uses: cost = (input tokens × input price + output tokens × output price + cache reads × cache price) / 1,000,000, then × documents × (1 + retry rate). Output tokens are a stated assumption — summaries here; translation would scale output with document length instead.

Scenario S1 — one-off small batch (50 docs/month)

Fifty small documents cost less than a coffee. The budget-relevant reading is the last column: per 1,000 documents you are in the ¥3–9 / $3–10 range across the low/high spread — including the 5% retry cushion. If someone quotes you a four-figure monthly "AI budget" for this workload, the number is not coming from token math.

Scenario S2 — repeated processing (500 docs/month, cached prefix)

The table below is an idealized warm-cache lower bound: it bills the 4,000-token shared prefix at the cache-read price on every request, i.e. it assumes the prefix stays cache-hot for the whole month. Real months land between the warm bound here and the cold range right after the table, depending on how request pacing compares with the vendor's TTL. The 4,000-token prefix clears OpenAI's documented 1,024-token minimum cacheable prefix, so caching applies.

Per 1,000 documents in the mid tier (twice the 500-doc column, per language): DeepSeek peak ¥4.04 (EN) / ¥4.10 (ZH), off-peak ¥2.02 / ¥2.05; OpenAI sol $5.11 (EN) / $5.17 (ZH); OpenAI Batch $2.56 (EN) / $2.58 (ZH). Three structural notes: (1) with a 4,000-token shared prefix the cache saving is modest at these document sizes — caching becomes dramatic only when the shared context is large relative to the document; (2) the discounts stack differently by vendor (Batch halves everything on OpenAI; DeepSeek halves by running off-peak — see the billing guide); (3) quarterly re-processing of the same corpus re-bills every request unless you cache at the application layer and nothing changed.

The warm bound is not the bill you should expect by default. If requests stop for longer than the cache TTL, the next request pays to write the cache again: OpenAI's GPT-5.6+ models bill writes at 1.25× input for the 30-minute TTL ($2.50/1M here) or 2.5× for 12 hours ($5/1M) — replacing the input charge on those tokens; DeepSeek has no write fee, so a cold request just pays the normal cache-miss input price. Computed on the mid EN workload, the spread is: warm $2.56 → cold-every-request $7.50 (30m TTL) or $12.65 (12h TTL) per 500 docs on OpenAI, and warm ¥2.02 → cold ¥6.06 on DeepSeek peak — roughly a 3× swing from caching alone. A one-shot backfill of 500 documents in a single afternoon behaves like the warm bound; one document per working hour all month behaves like the cold bound. Pick your end of the range from your own schedule, and treat a vendor's returned usage counts as the ground truth when costs matter.

An earlier version of this section labeled the OpenAI 500-doc figures ($2.58/$1.29) as per-1,000 numbers and mixed the English-sample table with Chinese-sample model counts; the tables and the per-1,000 sentence are now generated from one dataset per language and were corrected on 2026-11-12.

What is NOT in these numbers

• OCR — scanned paper needs text extraction first (a separate step with its own cost or its own quality risk); the tables assume clean digital text.
• Embeddings / vector storage — retrieval-augmented setups pay for embedding calls and a vector database; not modeled here.
• Human review — someone reading summaries and fixing mistakes is usually the largest cost in the pipeline; it never appears in an API bill.
• Peak traffic spikes — the monthly totals assume steady volume; a one-day 10× spike multiplies that day's cost by 10×.
• Model changes — rates moved to a different tier change the budget, not the arithmetic.

YYYSI tool packs vs vendor API — different products

If your need is occasional manual tasks (summarize one file now and then), the YYSI toolbox's AI tools cover that with 3 free site-wide trials, then one-time usage packs ($4.99 / 100 uses, $9.99 / 250) — a per-use product for human-driven tasks, with files processed through YYSI's server to the AI provider. A document pipeline (hundreds of documents, triggered automatically, results fetched by code) needs the vendor API with a billed account — usage packs are not designed for that and the trials will not stretch. Pick by shape of work, then budget with this page's method.

Budget checklist

1. Measure tokens on your real documents (tiktoken for OpenAI encodings; or the usage counts returned by one test call per document shape on your vendor) — never from page counts. If your text is Chinese, expect a higher token density than English (our samples: ≈1.3 vs ≈4–5 chars/token), and measure rather than assume a fixed multiple.
2. Write down the instruction prefix and whether it is stable enough to cache.
3. Assume an output length and say it out loud — output tokens often rival input cost on verbose tasks.
4. Add a retry multiplier (2–5% is typical) and accept that retries re-bill the whole request.
5. Decide which discounts legitimately apply: Batch only for deferable work; off-peak only on DeepSeek and only at night; caching only for genuinely shared prefixes.
6. List the excluded costs (OCR, embeddings, storage, human review) so the budget is honest about its boundary.
7. Re-check rates on the prices-data page or model-prices JSON before committing, and re-run the calculator with fresh numbers.

Try it with our documents

The six sample documents and the full assumptions/model file are the exact material behind every number above (YYSI-made synthetic text; no real companies or people). Tokenize them yourself and compare — then swap in your own documents and re-derive the low/mid/high anchors the same way.

• en-short.txt — EN short memo (298 chars) — Download sample · 308 bytes
  SHA-256: 44ad3365a3c5a03c90b45865502952062ffa7880239b4e040f147f0963b28b23
• en-mid.txt — EN mid memo (1,399 chars) — Download sample · 1431 bytes
  SHA-256: 2335e8f9f05f36d7bbc4185b92d0a5f7b5069b6a4726ce2918b568c9c532d2f2
• en-long.txt — EN long handbook excerpt (2,380 chars) — Download sample · 2434 bytes
  SHA-256: e77a14218205257db6d0d1ea174b853311e4711a244a6aed9ccdcd7aadc74731
• zh-short.txt — 中文短纪要（102 字） — Download sample · 266 bytes
  SHA-256: 677ad995e52b9abe8818c7ec75c4cca16bc0b9752ea25eb471322be9a54b3ae2
• zh-mid.txt — 中文中等备忘（401 字） — Download sample · 1100 bytes
  SHA-256: e0b9dcaa0887079844e3e79d4e010f69ba1838ef0d86b91cd38efb65d9edf749
• zh-long.txt — 中文长手册节选（667 字） — Download sample · 1778 bytes
  SHA-256: 8fa41650fd3be8648ec556d62735c1d45630dedc9b396c055ae15eaa84c39127
• budget-model.json — measured tokens, all assumptions and computed tables — Download sample · 4404 bytes
  SHA-256: 003bae8c60145976824e07a7543da670de4a7f50bd6eeb0523149579e61deaf7

Rates were verified on official pages on 2026-11-11 and re-verified on 2026-11-12 (sources linked above); the tokenizer was tiktoken o200k_base. The arithmetic script and its console output are preserved in YYSI's private run directory for reproducibility.