DocsAPI LogoDocsAPI

Bulk OCR Processing: Speed, Cost and Review Time, Measured

Nupura UghadeNupura Ughade
/November 3, 2026/12 min read
In short

Bulk OCR is a queue problem more than an accuracy problem. On a 10-core Mac, Tesseract went from 0.28 pages per second with one worker to 2.21 with ten, so 100,000 dense pages took 12.6 hours. Dropping from 300 to 150 DPI saved 27 percent of the time. Review hours, not processing hours, usually decide the schedule.

To OCR thousands of documents, put each file on a queue, process many pages in parallel, give every job an ID so a failed job can be retried without creating a duplicate, and send low-confidence results to a person instead of trusting them. Speed is the easy half. We measured it on a 10-core Mac: ten workers ran 7.8 times faster than one, eight workers already gave 90 percent of that, and 100,000 dense pages took 12.6 hours. The harder half is what happens when 400 files out of 50,000 are corrupt, upside down or in a language nobody planned for.

This guide has the measured numbers, a tested pipeline script, and the planning math for cloud and local processing. The numbers in the first sections come from Tesseract 5.5.2, a free engine, so you can repeat them. They are not DocsAPI numbers, which are covered later and come from our own benchmark.

How we measured

  • Pages: 60 synthetic full letter pages, each with 40 lines of 10 point text, rendered at 300 DPI. These are dense pages, denser than most invoices.
  • Machine: a 10-core Apple M5 Mac with 16 GB of memory, running one Tesseract process per worker.
  • Method: the same 60 pages for every worker count, timed from the first page started to the last page finished. Time per page by resolution used a single process and the mean of 6 pages.
  • Limits: one machine, one engine, English text. Treat the shape of the curves as the finding and time your own files for your own numbers.

How does speed scale with more workers?

WorkersPages per secondSpeedup over one workerHours for 100,000 pages
10.281.0x97.8
20.572.0x48.4
41.154.1x24.1
61.706.0x16.3
81.997.0x14.0
102.217.8x12.6

Scaling was almost perfectly linear up to 4 workers, then flattened. Going from 8 to 10 workers, a 25 percent increase, bought only 11 percent more throughput. Eight workers captured 90 percent of what ten delivered. The practical rule: size your pool to a little under the core count, not above it, and measure the last step before paying for it. A single Tesseract process gave 0.29 pages per second whether or not its threads were capped, so a script that loops over files one at a time leaves most of a modern machine idle.

Does a higher DPI make bulk OCR slower?

ResolutionSeconds per page (one process)
100 DPI1.91
150 DPI2.77
200 DPI3.10
300 DPI3.79
400 DPI3.98
600 DPI4.75

Yes, but far less than you would expect. From 100 to 600 DPI the page has 36 times as many pixels and took only 2.5 times as long. Time followed how much text there was to read more than how many pixels there were. The useful number is the saving from sensible downsampling: scanning or converting at 150 DPI instead of 300 cut the time per page by 27 percent. Whether that is safe depends on character height. In our accuracy tests, 10 point text read perfectly down to about 21 pixels per character, which 150 DPI gives, and failed below about 10. So 150 DPI is fine for 8 to 10 point print and too coarse for small footnotes. Test your smallest text before you downsample a whole archive.

Is limiting OCR threads worth it?

A common tip says to cap each Tesseract process at one thread, because its OpenMP threading can oversubscribe the CPU when you run many workers. We tested it with 10 workers on 40 pages. With the cap, 2.29 pages per second. Without it, 2.38. Single worker: 0.29 either way. On this build and machine the setting made no measurable difference. It costs nothing to try once on your own hardware, but do not expect it to rescue a slow batch. Our test cannot speak for other builds, other operating systems or other engines.

Three speeds, and why none of them is yours

Three different per-page times appear in our own material, and all are correct for their own pages:

  • 3.5 seconds for Tesseract on a dense full letter page in the test above, one process on an M5.
  • 1.8 seconds for Tesseract on a mid-tier laptop CPU in our 1,700-document benchmark, on a mix of real documents.
  • About 1.1 seconds for DocsAPI in the same benchmark, including the network round trip.

They differ because the pages differ, the hardware differs and one includes a network call. The benchmark was run by DocsAPI, so cite it as DocsAPI's own. What matters for planning is that page density moves the number by a factor of two or more, so a sparse invoice and a crowded bank statement are different workloads. That is why every plan below starts with a sample of your own files.

How long will a cloud batch take?

For a hosted API, use this formula: hours = total pages x seconds per page / parallel requests / 3,600. At about 1.1 seconds per page:

Total pages1 request at a time10 in parallel50 in parallel
10,0003.1 hours18 minutes4 minutes
100,00030.6 hours3.1 hours37 minutes
1,000,00012.7 days30.6 hours6.1 hours

Two cautions. A 40-page statement counts as 40 pages. And the parallel columns assume your plan allows that many simultaneous requests, so ask what concurrency and rate limits apply before you build a deadline on them. Do not compare this table with the local one above as if the workloads matched: the local test used dense pages on one 10-core machine, and this uses benchmark averages and a network.

What will it cost?

DocsAPI pricing starts at $0.02 per page, with volume discounts above 100,000 pages a month, and table extraction and classification are included. At list price that is $2,000 for 100,000 pages and $20,000 for 1,000,000 pages before any discount. Access starts with a demo, then a free 30-day trial for qualified lenders. Current terms are on the pricing page. A local engine has no per-page fee, and its cost is the machines and the engineering time to keep them running. For other pricing structures, see invoice OCR pricing models, and for bank statements specifically, bank statement OCR pricing.

A worked planning example: 250,000 pages

These are illustrative numbers built from the measurements above, so replace them with your own sample results. Suppose a backlog of 250,000 pages, and an assumed two minutes of human time for each page that needs review.

ItemCalculationResult
Cloud processing time, 20 parallel requests250,000 x 1.1 s / 203.8 hours
Local processing time, 10 workers, dense pages250,000 / 2.21 pages per second31.4 hours
Cloud cost at list price250,000 x $0.02$5,000
Review at a 5% review rate12,500 pages x 2 min417 hours
Review at a 3% review rate7,500 pages x 2 min250 hours

The machine work finishes in hours and the people work takes weeks. Two points of review rate are worth 167 hours, more than any rounding in the processing time. So the lever that decides the schedule is how many pages a person has to touch, which depends on clean scans, sensible thresholds and per-field confidence. The measured trade-off for confidence thresholds, including the fact that some wrong values arrive with high scores, is in how OCR works.

A pipeline script we ran

This is the shape of what we used for the scaling test, extended with the three things a real batch needs: a content-hash job ID, retries, and a failed list. We ran it on five good pages, one exact duplicate and one corrupt file.

import hashlib, subprocess, time, sys
from multiprocessing import Pool

def job_id(path):
    with open(path, "rb") as f:
        return hashlib.sha256(f.read()).hexdigest()[:16]

def ocr_one(path):
    jid, last = job_id(path), ""
    for attempt in range(3):
        r = subprocess.run(["tesseract", path, "stdout", "--psm", "3", "-l", "eng"],
                           capture_output=True, text=True)
        if r.returncode == 0 and r.stdout.strip():
            return jid, path, "done", r.stdout
        last = r.stderr.strip() or "empty output"
        time.sleep(2 ** attempt)             # growing delay between retries
    return jid, path, "failed", last

if __name__ == "__main__":
    paths = sys.argv[1:]
    seen, unique = set(), []
    for p in paths:                          # skip exact duplicate files
        j = job_id(p)
        if j not in seen:
            seen.add(j)
            unique.append(p)
    done, failed = {}, {}
    with Pool(8) as pool:
        for jid, path, status, payload in pool.imap_unordered(ocr_one, unique):
            (done if status == "done" else failed)[jid] = (path, payload)
    print("received", len(paths), "unique", len(unique), "done", len(done), "failed", len(failed))

The output on our test: received 7, unique 6, done 5, failed 1. The duplicate was skipped, and the corrupt file went to the failed list with its error attached instead of stopping the run. In production, persist the two dictionaries to a database so a restart resumes where it stopped, and cap the pool at what your hardware or plan allows.

The six parts of a pipeline that survives bad files

  1. A queue. Workers pull from it. A loop over a folder in one script loses its place on a crash.
  2. A job ID per file. A hash of the contents means the same file arriving twice is visible, and a retry updates the same record.
  3. Retries with backoff. Network errors and rate limits are normal at volume. Retry a few times with growing delays, then give up.
  4. A failed list. Corrupt, encrypted and empty files end up here with the error, and a person looks once.
  5. A confidence gate. Fields below your threshold go to review. How to measure OCR accuracy shows how to choose it from a sample.
  6. Counters. Files received should always equal done plus failed plus in review. If it does not, files are going missing.

Prepare the files before you send them

  • Split combined scans. One 80-page scan is often 12 documents. Split at document boundaries so one bad page does not cost the other 79.
  • Fix orientation and tilt. A tilt past about 5 degrees collapsed accuracy in our tests, and straightening restored it. See document detection before OCR.
  • Drop blank pages. Duplex scanners create blank backs that add cost and noise.
  • Catch locked files. Password protected or corrupt PDFs fail every time, so move them to the failed list before the queue.
  • Keep the source path next to the content hash so a person can always find the original.

What to store, and how to keep review from becoming the bottleneck

ColumnWhy you need it
job_id (content hash) and source_pathDedupe, safe retries, finding the original
document_type and page_numberReport accuracy by type, trace a value to a page
field_name, value and confidenceThe data, and the basis for routing to review
statusdone, in_review, failed or accepted_by_reviewer
reviewer_correctionYour best data for tuning thresholds

Design the review screen on purpose, because at volume it is where the hours go. Show the page image beside the value. Sort the riskiest items first. Group by document type so a reviewer builds speed on one layout. Let a reviewer accept a whole page in one click. And sample a small share of automatically accepted items, since that is how you find a quiet problem confidence scores do not reveal. Mixed streams need classification first, as in document classification software, and exact copies are only half of duplicates, as duplicate invoice detection explains.

Five numbers to watch while a batch runs

  • Pages per minute: a sudden drop means a limit, a slow network or a stuck worker. Compare against the flat part of your own scaling curve.
  • Failure rate: a jump from 1 percent to 8 percent usually means a bad folder or a changed file source.
  • Review rate: a rise means a new document type or a worse scanner entered the stream.
  • Queue age: the oldest waiting job. If it keeps growing, workers cannot keep up.
  • Received versus accounted for: alert on any gap.

Local engine or cloud API for a large batch?

QuestionLocal engine (Tesseract, PaddleOCR)Cloud API
Who sets the speed limit?Your hardware: 2.21 pages per second on our 10-core MacYour plan's concurrency
Cost shapeServers and engineering timePer page, from $0.02 for DocsAPI
Tables and handwritingWeaker: 64% for Tesseract on bank statement tables in our benchmarkBuilt for them: 91% for DocsAPI on the same test
Where the data goesStays inside your environmentSent to the provider, so check retention

If documents must never leave your environment, that points to a local engine. DocsAPI runs as a cloud API, and self-hosting is a question for the demo. The two free engines are compared in PaddleOCR vs Tesseract vs DocsAPI, and the wider build-or-buy question for invoices is in build vs buy invoice OCR. Large organizations often add requirements around access control and audit, which enterprise document OCR covers.

Security and retention for large batches

  • Know where files sit while they wait in your queue and who can read that storage.
  • Ask how long documents and extracted data are kept. DocsAPI keeps them for a short, configurable retention period, then deletes them, and does not train on customer documents.
  • Delete your own temporary copies when a batch completes, automatically.
  • Keep an audit trail of job ID, time and reviewer without keeping the document longer than needed.
  • If health data is involved, confirm a business associate agreement first. DocsAPI is HIPAA-eligible with a BAA.

Run a pilot before the full batch

Pull a random sample of 200 to 500 files from the real batch, including the ugly ones, and run them through the full pipeline with real reviewers. Record seconds per page, failure rate, review rate and cost, then scale up with the tables above. A scanner that produced upside-down pages for a month shows up in a sample of 500 and costs a day. It shows up in a full run of 500,000 and costs a rerun. Parallel-run sample size explains how big a sample you need to trust the result. For invoice workloads, accounts payable OCR has a fill-in cost model, and the month-end close bottleneck shows where the hours go.

DocsAPI processes about 4 million pages a month, so if your volume is in that range, raise concurrency, retention and support expectations in the demo. To see how engines compare by document type before you commit, read the benchmark, and for how tables and fields fail and how to catch it, OCR layout analysis, tested.

Common questions

Frequently asked questions

Put the files on a queue, process many pages in parallel, give each file an ID based on a hash of its contents so retries are safe, move files that keep failing to a separate list, and send low-confidence fields to a person for review.

In our test on a 10-core Mac, throughput scaled almost linearly to 4 workers, reached 7.0 times a single worker at 8, and 7.8 times at 10. Eight workers delivered 90 percent of the ten-worker speed, so size the pool a little under your core count and measure the last step.

On our 10-core Mac, Tesseract took 12.6 hours with 10 workers on dense full pages. For a cloud API at about 1.1 seconds per page, it is about 3.1 hours with 10 parallel requests and 37 minutes with 50. Page density moves these figures by a factor of two or more, so time a sample of your own files.

Somewhat. In our test, seconds per page rose from 1.91 at 100 DPI to 3.79 at 300 and 4.75 at 600, so 36 times the pixels took 2.5 times as long. Dropping from 300 to 150 DPI saved 27 percent, which is safe for 8 to 10 point print but not for tiny footnotes.

DocsAPI starts at $0.02 per page, with volume discounts above 100,000 pages a month, so 100,000 pages is $2,000 at list price. Table extraction and classification are included. Add the cost of people reviewing the pages that fall below your confidence threshold, which usually outweighs the processing cost.

A well-built pipeline retries a few times with growing delays, then moves the file to a failed list with the error attached. In our test run a corrupt file went to that list and the other files finished normally. You review the list once instead of rerunning the batch.

Use a hash of each file's contents as the job ID so exact copies match and are skipped. Near-duplicates, such as the same invoice scanned twice, need field-level matching on values like invoice number, date and total.

DocsAPI processes about 4 million pages a month. Access starts with a demo, then a free 30-day trial for qualified lenders. Ask in the demo about concurrency, rate limits and retention for your volume.

Nupura Ughade

Content Marketing Lead, DocsAPI

Nupura Ughade creates clear, insightful content on OCR, document AI, and fintech. She combines technical depth with real-world finance use cases to help engineers and operations leaders navigate digital transformation with confidence.

Want to see it on your own documents?

Try our free OCR tool in your browser, or book a demo to see how DocsAPI reads the document types covered in this guide.