Generator
SEC Filing Chunk Optimizer
SEC filing chunk sizing + 10-K chunking cost calculator. Pick archetype, chunk size, overlap, strategy, and embedding model.
Runs in your browser. Nothing you enter is uploaded, and no account or API key is needed.
1. Configure chunk strategy
Share of each chunk repeated at the start of the next one.
Search queries embedded against the index, about 40 tokens each.
Estimated chunks for one 10-K (full body)
105 chunks
Average 1,018 tokens each at a 1,024-token target, 15% overlap, structural split; 106,890 tokens embedded.
Ingest $0.002138, 100 queries $0.000080, text-embedding-3-small
Strategy note
Respects Items / section headers / speaker turns. Preserves table blocks by keeping heading+table together. Chunk sizes are uneven but semantically clean.
No structural warnings at these settings. Still run a retrieval eval before production — heuristics can't replace ground truth.
Archetype reference: Form 10-K main document: business, risk factors, MD&A and financial statements, ~12 Items, dense tables in Items 7 and 8. Median of 15 recent 10-Ks sampled from EDGAR (2026-10-19).
Detail
Total chunks
105
Avg tokens/chunk
1,018
min 1,024, max 1,024
Ingest cost (once)
$0.002138
text-embedding-3-small
Query cost (100 re-embeds)
$0.000080
Tokens embedded
106,890
3. Compare strategies (same archetype + chunk size)
| Strategy | Chunks | Avg tok | Min / Max | Ingest cost | Tradeoff |
|---|---|---|---|---|---|
| structuralselected | 105 | 1,018 | 1,024 / 1,024 | $0.002138 | Highest fidelity; uneven chunk sizes. |
| recursive | 105 | 1,018 | 614 / 1,024 | $0.002138 | Cheap + deterministic; blind to tables. |
| semantic | 100 | 1,061 | 409 / 1,433 | $0.002122 | Coherent prose groups; variable sizes, higher compute. |
How the estimate works
stride = chunk_size × (1 − overlap_pct) base_count = ceil(total_tokens / stride) structural → max(boundary_count, base_count) recursive → base_count semantic → ceil(base_count × 0.95), wider size variance ingest_cost = tokens_embedded × $/M_tokens query_cost = (40 × n_queries) × $/M_tokens
Pricing verified 2026-10-18.
How to use it
- Pick a filing archetype (10-K body, MD&A, notes to the financial statements, earnings-call transcript) and an embedding model.
- Choose a chunking strategy (structural, recursive or semantic), the chunk size in tokens and the overlap.
- Read the estimated chunk count for one filing, the average chunk size, the tokens embedded and the one-time embedding cost.
- Read the warnings: small chunks on table-heavy filings, high overlap, semantic chunking under 1K tokens and others.
- Compare the three strategies at the same settings in the table, then confirm the choice with a retrieval eval on your own filings.
Questions people ask
What chunks does the tool produce?
None: it is an estimator. From a representative token count for each filing type it estimates how many chunks each strategy produces at your chunk size and overlap, their size range, the tokens embedded and the embedding cost. It does not download, parse or split an actual filing.
Why not use a generic text splitter?
A generic recursive splitter ignores document structure, so it can cut a table mid-row or split an Item section; the tool warns about this for table-heavy archetypes. Structural chunking that follows Items, headings and speaker turns keeps those units intact, at the cost of uneven chunk sizes.
How big are the chunks?
You set the target, from 256 to 8,192 tokens, and an overlap from 0 to 30%; the page starts at 1,024 tokens with 15% overlap. The estimate shows the average and the expected minimum and maximum chunk size for the chosen strategy. Larger chunks mean fewer, more diluted embeddings.
Does it handle XBRL?
No. The estimate works from token counts of the narrative filing and does not read XBRL. For exact reported figures, pull the XBRL facts from SEC EDGAR directly rather than from chunked text.
What's the optimal chunk strategy for filing Q&A?
There is no universal answer; it depends on your questions and your retriever. Structural chunks of roughly 512 to 1,024 tokens with modest overlap are a common starting point for 10-K question answering. Measure recall on your own question set before settling; this tool shows the cost side of the choice.
Related tools
- Calculators Financial Document Token Estimator
Paste a 10-K, 10-Q, 8-K or earnings transcript and see token count + one-pass extraction cost across ten frontier LLMs, with cache-hit toggle.
- Playgrounds Structured Schema Validator for Finance
Paste LLM JSON output and validate against four pre-built finance schemas — research output, trade decision, risk snapshot, peer comparison — with sanity checks on unit and GAAP basis.
- Playgrounds Hallucination Detector
Paste a source document + an LLM's extraction. Every numeric claim in the output is checked against the source. Client-side. Catches silent fabrication before it ends up in your pipeline.
Articles
- 10 min read Financial QA LLM Benchmarks 2026: FinanceBench & Fin-RATE
Financial QA LLM benchmarks 2026: FinQA, FinanceBench, DocFinQA, and Fin-RATE scores, plus whole-filing read costs on the current model lineup.
- 14 min read Long-Context Financial Question Answering: SEC Filings & RAG 2026
Long-context financial question answering over SEC filings, annual reports & earnings calls with RAG: eight LLM tasks, chunking, and 2026 benchmarks.
- 7 min read DeepSeek V4 for Finance 2026: SEC Filing Extraction Cost
DeepSeek V4 for finance 2026: V4.1-Flash reads a full 10-K for about $0.041 at $0.30/$1.20 per Mtok, half that off-peak, with a 1M-token window.
Use it from code
The same calculation as a JavaScript module you can import. It runs where you import it, with no request, key or rate limit.
import { compute } from "https://aifinhub.io/engines/sec-filing-chunk-optimizer.js";