Parse Scanned PDFs for RAG with EasyOCR: Free OCR Offers You Phrases, Not a Doc

Conventional OCR reads pixels and returns textual content rectangles. Every little thing else, sections, tables, figures, studying order, is a separate structure drawback the engine refuses to take a look at. The 2 fashions behind it are textual content detection (discover rectangular areas of the picture that include textual content) and textual content recognition (learn every area’s pixels and return characters with a confidence rating). The output is a flat listing of (bbox, textual content, confidence) per detected area.

That’s every thing EasyOCR (or Tesseract, or PaddleOCR) does. The engine reads pixels and returns textual content rectangles. A two-column web page comes again as a flat listing of left-and-right textual content containers intermixed by y-coordinate; the engine doesn’t know there are two columns. A desk comes again as a grid of disconnected cells the engine can’t inform other than common paragraphs. A determine caption is simply one other textual content field. The web page header, web page footer, marginalia all present up as containers too.

Something that wants “this textual content is a bit heading” or “these 4 containers are one desk row” wants a second mannequin on high, a structure mannequin. The structure mannequin reads the OCR output plus the web page picture and classifies every area (heading, paragraph, desk cell, determine, caption, footer…) and teams them right into a studying order. That’s what Article 5bis (Azure DI), Article 5ter (Docling), and Article 5quater (imaginative and prescient LLM) all add over the OCR step. With out one, you’ve got “OCR output”, not “a parsed doc”.

EasyOCR is the cleanest demonstration of “conventional OCR” as a category. The library is small (~150 MB of mannequin weights cached on first name), free, CPU-only by default, native. The entire library API is 2 calls: construct a Reader for the languages you want, then hand readtext a picture. Every detection comes again as a triple: the polygon across the textual content, the recognised string, and the recogniser’s personal confidence.

import easyocr
import fitz
import numpy as np

reader = easyocr.Reader(["en"], gpu=False)        # first name downloads ~150 MB

# render web page 1 of a scanned PDF to a numpy array EasyOCR can learn
web page = fitz.open("information/contracts/scanned_amendment.pdf")[0]
pix = web page.get_pixmap(matrix=fitz.Matrix(2.0, 2.0))   # 2x zoom = ~144 DPI
img = np.frombuffer(pix.samples, dtype=np.uint8).reshape(
    pix.top, pix.width, pix.n,
)

# the recogniser: one picture in, one triple per detected textual content area out
detections = reader.readtext(img)
for quad, textual content, conf in detections:
    # quad = [[x0,y0], [x1,y0], [x1,y1], [x0,y1]]  in pixel coords
    print(spherical(conf, 2), textual content)

parse_pdf_easyocr wraps that loop. It walks each web page of the PDF, renders every to a numpy array, calls readtext, converts the pixel-space polygons again to PDF coordinates, and packs the detections into the identical dict-of-tables contract as the opposite parsers, similar line_df, similar parsing_summary, similar downstream shoppers, besides that solely these two keys carry information. Each different slot (page_df, image_df, toc_df, span_df, object_registry, cross_ref_df) comes again as an empty DataFrame. That isn’t a missing-feature bug; it’s precisely what “conventional OCR” means.

parsed = parse_pdf_easyocr(
    "information/contracts/scanned_amendment.pdf",
    languages=("en",),         # add "fr", "de", ... for multilingual scans
    render_scale=2.0,          # 2.0 = ~144 DPI ; increase for small fonts
    gpu=False,                 # CPU-only by default ; set True if CUDA accessible
    confidence_threshold=0.0,  # filter low-confidence detections if wanted
)

parsed["line_df"]              # textual content + bbox + confidence per detection
parsed["parsing_summary"]      # methodology, web page rely, line rely, render scale
# Each different key (page_df, image_df, toc_df, span_df, object_registry,
# cross_ref_df) is an empty DataFrame ; EasyOCR has nothing to place there.

The signature kwargs are the one knobs:

5 structural artefacts that the RAG pipeline wants and that conventional OCR can’t produce, no matter how large the popularity mannequin is. Every one breaks a downstream operation the remainder of the collection depends on.

• TOC / sections. Cross-reference decision (Article 11) and section-scoped corpus retrieval (Article 17) each depend on toc_df. EasyOCR returns zero rows. The dispatcher can’t route “reply in Part 3.2” questions as a result of Part 3.2 has no boundary.
• Particular person figures contained in the web page. A scanned 30-page contract might include six chart screenshots embedded within the physique textual content. EasyOCR treats the entire web page as one picture and returns textual content from across the figures; the figures themselves by no means turn into rows. A downstream pipeline that should retrieve “the chart on web page 14” has no deal with.
• Studying order on multi-column / multi-zone pages. A two-column scientific paper web page comes again top-to-bottom throughout each columns intermixed: left-line-1, right-line-1, left-line-2, right-line-2… Technology reads rubbish. Sidebars, footnotes, marginalia all leak into the principle circulation.
• Desk cells. A scanned schedule of prices or premium desk comes again as a flat listing of disconnected textual content containers (the row labels in a single column, the values in one other, the unit headers some other place). The connection “this worth belongs to this label” is misplaced. Article 5 (doc parsing) opens on precisely this failure mode (“the parser walked the desk cell by cell and joined them right into a flat string”). Format-aware engines run a separate TableFormer-style mannequin to reconstruct rows × columns × headers.
• Font / weight / dimension indicators. OCR recovers character form, not its typographic encoding. “This line is in daring 18pt” is info the structure engine reads from the web page rendering; EasyOCR throws it away. Headings, emphasis, footnotes lose the cue that might have categorised them.

Take the third one, studying order, as a result of it’s the one which quietly corrupts a solution. EasyOCR returns textual content containers sorted by their y-coordinate. On a two-column web page the 2 columns sit on the similar heights, so the containers come again interleaved: first line of the left column, first line of the precise column, second line of the left, and so forth. The prose reads as a zigzag, and era quotes the zigzag.

The one sentence: the OCR step recovers textual content, the structure step recovers what makes the textual content usable. Article 5ter (Docling) and Article 5bis (Azure DI) add the structure step on high of the identical OCR. Article 5quater (imaginative and prescient LLM) folds the 2 into one name. EasyOCR stops on the OCR step.

On the identical 1974 scan, Docling extracts extra characters (5,423 vs 4,952), the web page boundaries, eleven TOC entries, and 4 determine areas. EasyOCR extracts textual content rectangles and stops. The 2 engines agree on the character stage, each OCR with the identical recogniser-class accuracy, however Docling’s structure go turns the OCR output right into a doc.

The attention-grabbing comparability will not be towards fitz (fitz returns zero on a scan) however towards the following engine up: Docling, the native layout-aware parser from Article 5ter. The comparability is cleaner than it seems: Docling’s default OCR backend is EasyOCR itself. Similar recognizer studying the identical pixels; the distinction is every thing Docling builds round it.

EasyOCR is the emergency package deal of the household: much less visibility into the doc, less complicated dependencies, sooner to deploy when the constraint is operational moderately than pedagogical. 4 slim circumstances hold the door open.

• Receipt-class paperwork. A 1-page bill or receipt with no headings, no sections, no figures, no tables-with-merged-cells. Format is trivial; the recogniser is the entire job. Including Docling’s 2× compute buys construction the doc doesn’t have.
• Per-region confidence as a era suggestions sign. Technology (Article 8) can learn the row’s confidence from the cited passage and warn the consumer when the reply rests on a 0.3-confidence little bit of OCR. Docling doesn’t ship that column. For pipelines the place this sign is load-bearing, EasyOCR (or working EasyOCR alongside Docling) is the reply.
• Non-Latin scripts at scale. EasyOCR ships pretrained fashions for 80+ languages together with Chinese language, Japanese, Korean, Arabic, Hindi, Cyrillic. Docling’s OCR stack is extra restricted in non-Latin protection on the time of writing.
• Operational constraints that block Docling. Corp SSL inspection breaks the HuggingFace mannequin obtain. Home windows blocks symlinks with out Developer Mode. The manufacturing picture has a strict dependency price range. Air-gapped deployment with no option to ship 3 GB of structure weights. In each considered one of these, EasyOCR’s 150 MB cached mannequin + CPU inference goes by the place Docling doesn’t. You see much less of the doc, however you see one thing.

Exterior these circumstances: default to Docling on scans, Azure DI on regulated-cloud-OK retailers, imaginative and prescient LLM when the doc has handwriting / signatures / a non-textual semantic layer. The adaptive-parsing dispatcher (Article 10) routes routinely.

OCR recovers characters. Format recovers what makes the characters helpful, sections, figures, desk cells, studying order. The default engine for scans is the one which does each. The total Article-5 household traces up by the identical axis:

EasyOCR is the OCR flooring, what you get if you cease at recognising characters and by no means ask “and the place are they on the web page?” The query issues. “The place on the web page” makes the distinction between an inventory of textual content containers and a parsed doc. The dispatcher of Article 10 (adaptive parsing) picks the precise engine per web page; this text exists so the dispatcher is aware of what it offers up when it picks a budget one.

EasyOCR is probably the most reachable conventional OCR engine in 2026; PaddleOCR (Baidu) and Tesseract (Google, decades-old) sit beside it in the identical household. The structure step on high is what separates “OCR” from “doc parsing”; Docling (Article 5ter) and Azure DI (Article 5bis) each add it, on native {hardware} and within the cloud respectively. The correct cross-reading is the structure literature (Smock et al. 2022 for desk construction, Auer et al. 2024 for the complete structure cascade) and the choice OCR engines for non-Latin scripts.

Similar course because the article: