PDF as Images vs Text: What Should You Feed an LLM?

You have a PDF and a multimodal model. You can render each page to an image and let the model look at it, or you can extract the text and send that. Since GPT-4o, Claude and Gemini all read images natively, skipping the extraction step is tempting: one fewer moving part, and the model sees the page exactly as it is. But letting the model see the page is not free, and it is not automatically more accurate. Here is the honest trade-off, and a rule for which to reach for.

The short version: for text-heavy documents you send more than once, such as RAG, chat over a knowledge base, or repeated analysis, extracted text is usually cheaper and more reliable. For a handful of visually complex pages you analyze once, such as a chart, a diagram, or a scanned form where position carries meaning, page images can be worth it. Most real pipelines end up using both.

The two ways to put a document in context

Approach one, images: render each page to a PNG and pass it to a vision model, which reads the pixels directly. Approach two, text: extract the document to plain text or Markdown and pass that. Both end with the model reasoning over your document. They differ in what they cost, how faithfully the content survives, and what you can do with it downstream.

What page images actually cost in tokens

A page image is not one token. It is priced by area. Vision models scale the image and split it into tiles, then charge per tile plus a base cost, so a single page commonly lands anywhere from a few hundred to over a thousand tokens depending on the resolution you send and the detail mode you pick. Send it at low resolution to save tokens and small print and fine table lines blur; send it at high resolution so the model can read them and the token count climbs.

That cost is per page, per call. Extracted text of the same page is often a few hundred tokens, and once it is cleaned it can be far less. The gap looks trivial on one page and one question. On a 30-page report answered a hundred times a day, or a knowledge base queried continuously, it compounds into the bulk of your bill.

• Images are billed by resolution, not by how much text is on the page, so a mostly-blank page can cost about as much as a dense one.
• Reading small print or fine table gridlines needs high detail, which means more tiles and more tokens.
• You pay the image cost on every call, because there is no cheaper already-parsed version to reuse.

Where sending images genuinely wins

This is not an argument for text everywhere. Some information only exists in the visual layer, and any text extraction throws it away. When the layout is the meaning, a vision model is the right tool, and pretending otherwise gives you worse answers.

• Charts and graphs, where the trend lives in the shape of the line, not in any text you could pull out.
• Diagrams, schematics and figures that describe relationships spatially.
• Handwriting and margin notes that trip up plain OCR but that a strong vision model can often read in context.
• Forms where a value's position on the page carries meaning, and a linearized text version would lose which field it belongs to.
• One-off analysis of a few pages, where wiring up extraction is more work than the job is worth.

Where extracted text wins

For the far more common case, documents that are mostly text and tables and that you send more than once, extracted text is the better substrate, and not only on price.

• Cheaper at scale: clean text is compact, and you can cache and reuse it instead of re-paying the image cost on every call.
• Retrievable: text chunks embed cleanly for RAG, while a page image is a single opaque blob that is much harder to chunk and rank.
• Citable: you can point back to a heading, a line, or a table cell. 'It is somewhere in this image' is not a citation.
• Inspectable: you can read exactly what the model received and catch a bad extraction before it becomes a wrong answer.
• Portable: text flows into any prompt, any model and any pipeline, with none of the per-provider quirks of image handling.

The RAG catch, specifically

Retrieval is where the difference gets sharp. A RAG system splits a corpus into chunks, embeds them, and pulls back the few most relevant pieces for each query. Text splits naturally on headings and paragraphs into chunks that mean something on their own. A page image does not split at all: you either embed the whole page with a vision embedding model, which is coarse and expensive, or you fall back to text anyway to get usable chunks. For anything you query repeatedly, clean text is the substrate that actually retrieves well.

A simple decision rule

1. Text-heavy document you send more than once, such as RAG, chat over docs, or repeated analysis: extract it to clean Markdown.
2. A few visually complex pages, such as charts, diagrams, handwriting, or position-sensitive forms, analyzed once: send those pages as images.
3. A document that is mostly text with a couple of critical figures: extract the text, and attach images of only the pages that need the visual.
4. Unsure? Start with extracted text and measure. Reach for images only on the pages where text clearly loses information.

The framing that trips people up is treating this as all-or-nothing. The strongest pipelines extract text for the large majority of pages that are text and tables, and reserve image input for the handful of pages where the visual genuinely carries the answer. You get accuracy where it matters, and you are not paying image prices for paragraphs.

Why bad extraction pushes people to images

A lot of the enthusiasm for 'just send the image' is really frustration with bad extraction. When a PDF comes out with broken words, flattened tables and empty scanned pages, letting the model look at the page feels like the only way to get the real content back. But that is fixing a text-quality problem with a token-cost problem. The better move is extraction that does not lose the structure in the first place.

That is the job PackForAI does: it turns PDF, DOCX, PPTX, XLSX, CSV and JSON into clean, compact Markdown, keeps tables as tables, rebuilds real dates from spreadsheet serials, recovers scanned pages with OCR, and shows a before-and-after token count on every file so you can see exactly what you are sending. In its own demo that meant 24,532 tokens down to 8,586, about 65 percent smaller. Get the text right and the reason to pay for images narrows to the pages that truly need it. You can try it on one document at packforai.com, no account needed for the first one.

Send the page as an image when the layout is the meaning. Send text when the meaning is the text, which, for most documents, it is.