Can ChatGPT Read Handwriting? What Happens with Historical Documents

ChatGPT can read clear, modern handwriting reasonably well: a shopping list, a note from a colleague, a legible twentieth-century letter. Historical documents are a harder test, and on old handwriting OpenAI's models have lagged in published tests. This article explains why, separates the ChatGPT app from the models behind it, and shows what a model built for historical documents, such as Leo's ATR-1, does differently.

The short version. When you paste a manuscript into the ChatGPT app, the image is downsampled before the model reads it, so fine marks are averaged away: a macron, a hairline abbreviation stroke, the difference between a long s and an f. The model is also a text generator. Where it cannot read a word it tends to produce the likeliest one rather than mark a gap, and where it meets an old spelling it tends to quietly modernise it. Its errors read fluently and are hard to catch. ATR-1, Leo's own model, is tuned for exactly this material: it reads the image at high resolution, it is trained to transcribe what is on the page rather than normalise it, and it checks its own output for failure.

That is the short version. The longer one is worth reading, because knowing why ChatGPT slips tells you when it is safe to use, and when a specialised model is the better choice.

What ChatGPT Actually Is, for This Task

Start with a distinction that is easy to miss. ChatGPT is a chat app. OpenAI's models (the GPT family) are what the app runs on, and the same models can be reached through OpenAI's API or through tools built on it. In the app you upload a photo and get a conversational answer. You don't choose how much image detail the model receives, and the model isn't instructed to transcribe faithfully. Through the API, whoever builds the tool sets the image detail and the instructions. So "ChatGPT can't read this" and "OpenAI's model can't read this" are not quite the same claim.

Underneath, ChatGPT and its peers (Claude, Gemini) are vision-language models (VLMs): a large language model joined to a vision encoder. The encoder turns the image into a sequence of embedding vectors. The language decoder then writes text one token at a time, each token conditioned on the image and on everything already written.

That last clause is where the risk lies. A dedicated handwritten text recognition (HTR) engine is image-first: it reads characters from the pixels, and when the ink is ambiguous it misreads a letter. A VLM leans on text. Its decoder carries a strong learned sense of what English, French or Latin usually looks like, and that sense pulls the output toward common, well-formed sequences. When the visual evidence is thin, the language prior can fill the gap. So the failure modes differ in kind: OCR and HTR engines miss letters, while VLMs can produce text that was never on the page. We set out the fuller distinction in HTR vs OCR. It belongs to the broader question of which HTR software actually fits historical work.

The Resolution Problem: What the Model Never Sees

The first reason is physical, and it happens before any reading starts.

VLMs do not take in raw pixels. They tile the image into patches and turn each patch into a fixed budget of tokens. As OpenAI's image documentation describes it, its current models cut an image into 32×32-pixel patches, and in high-detail mode they scale down any image above a budget of about 2,500 patches, so a 2048×2048 photo is read at about 1600×1600 pixels. Older models shrank the image to at most 768 pixels on its shorter side and read it in 512×512 tiles. Claude and Gemini work within comparable per-image budgets. Every general model, inside any tool, has a resolution limit of some kind. In a chat app, where you don't control the detail setting and photos are often resized on upload, the limit bites hardest.

For a photograph of your dog this is plenty. For a densely written folio it is not. One tile may have to stand for a whole cluster of words, and anything finer than the tile's effective resolution is averaged into its neighbours before the language model receives a single token. That is why "just zoom in and it'll see the detail" doesn't hold: the model isn't looking at your zoomed image, it is looking at a compressed encoding of it.

The marks that vanish first are the ones that carry scholarly weight:

• The long s (ſ), used at the start and in the middle of words from the late eighth century to the early nineteenth. Its faint descender is exactly the kind of hairline detail that survives downsampling poorly, and even systems built for the job often misread it as f.
• The macron or titulus, a bar over a vowel standing for an omitted n or m. It is a thin horizontal stroke. Average it out and dñi silently becomes dni, or is "corrected" to something plausible.
• Brevigraphs and contraction marks generally, the dense scribal shorthand that fills legal and administrative hands

None of this is exotic to a paleographer. It is the ordinary furniture of the page, but it lives at the fine detail a downsampled image loses first. We treat this shorthand at length in our guide to manuscript abbreviations and ligatures, because reading it correctly is often the whole task.

This is the first thing Leo's ATR-1 was built to avoid. It reads the page image at high resolution, where general models downsample, so the hairline that separates ſ from f is still there when the reading happens.

The Confabulation Problem: Fluent, Plausible, Wrong

The second reason is less obvious, because it doesn't look like a failure.

When an HTR engine cannot read a word, it produces a low-confidence guess that usually looks wrong: a misfired character, a nonsense string. You can see the damage. A VLM given the same word may do what a language model is built to do and write the most probable continuation: a grammatical, period-appropriate reading that may not be on the page. A 2026 benchmark of historical print and handwriting made the same point: the dangerous error now is no longer garbled text you can see, but the fluent misreading you won't notice. We explain why fluent AI output is the hardest error to catch separately.

Prompting helps only so far. He et al.'s 2025 study, Seeing is Believing?, built a benchmark because GPT-4o-class models often failed to abstain when they could not read degraded text, and "saw" plausible content instead. A better prompt reduced the problem but did not remove it.

Asking the model to check itself can also backfire. In Benchmarking Large Language Models for Handwritten Text Recognition (Crosilla, Klic and Colavizza, 2025), asking GPT-4o to correct its own transcription of historical Italian pushed its character error rate up, from about 61% to 77%. The model reasoned its way further from the page toward what "should" be there.

Newer general models invent less than they did, but their characteristic error is quieter still: normalisation. Unsure of an old spelling, a general model tends to write the more probable, modern form: the for ye, your for yo[u]r, a regularised u or v. The result looks exactly like a correct reading. That is not one vendor's flaw; it follows from training a model to produce clean, readable text. ATR-1 is trained the other way: to transcribe what is on the page, and not to over-correct or silently modernise it. You don't have to prompt it for faithfulness. It is the default.

For anyone building a genealogical database, that difference matters a great deal. A silent u/v substitution, a misread long s, an abbreviation expanded wrongly: each can change a name, a place or a date, and then carry into a searchable index where the error is invisible. If you work with baptism and burial entries, our method for transcribing parish records faithfully treats exactly this risk.

What the Published Tests Say

People reach for ChatGPT because it is genuinely strong on modern material. The trouble comes from assuming that holds for the archive.

In historian Mark Humphries' November 2025 test on 18th- and 19th-century English handwriting, OpenAI's model made more errors than Google's and Anthropic's.

An earlier, wider study points the same way for older and non-English hands. Crosilla, Klic and Colavizza (2025) tested models of the GPT-4o and Claude 3.5 generation. On modern English handwriting (the IAM dataset) they scored around 1.7% character error rate, comfortably ahead of a specialised baseline. On older material the picture changed. On historical Italian, zero-shot GPT-4o reached roughly 61%, and on Early Modern German every general model tested went above 70%. On both, a specialised HTR model did markedly better. The authors also found a strong English bias.

Two caveats travel with these figures. Results vary by collection: on some historical English sets the general models did well, so "specialist always wins" would overstate it. And model versions turn over fast. None of these tests covers the GPT-6 family, so read them as a pattern, not a verdict on today's models. The pattern is this: as a hand gets older, more degraded and less English, general models make many more errors. For the wider field, see how today's AI models perform on old handwriting and how Gemini handles old handwriting.

That gap is what ATR-1 was made for. A general model is trained to do almost everything; reading a seventeenth-century hand is a small, specialised task its makers have little reason to train for. ATR-1 is a Transformer fine-tuned on images of historical documents, handwritten and printed, and it reads them out of the box, with no training on your particular hand.

Printed Pages Are a Different Question

Everything above is about handwriting. Print is another matter. ATR-1 reads print too, historical and modern, and keeps what conventional OCR tends to lose: the long s, the macron, the archaic spelling. But for a clean, legible modern page you only want to read, the OpenAI family has a strong, cheap option.

A clean, legible printed page, such as a 19th-century book or a typed report, is something a small model reads well. Inside Leo, GPT-6 Luna reads a page like that for 0.02 credits an image, roughly a quarter to under half a US cent depending on your plan. A job rounds up to a whole credit, so 50 images cost 1 credit. In our tests on clean single-column books and typescripts it was as good as the alternatives. On early-modern type it did better than conventional OCR, which often reads the long s as an f.

Two limits are worth knowing. Small general models tend to modernise early-modern spelling, which is fine for reading the text but not for a transcription you'll quote. And on a dense, multi-column newspaper page, a small model can stop partway through without saying so, returning a clean-looking transcription of a fraction of the page. For early-modern type, Fraktur, newspapers or anything you will quote, use ATR-1, which keeps the spelling as printed. We explain why historical print trips up older engines in HTR vs OCR.

The Practice Worth Keeping

None of this makes general models useless to a historian. It means choosing the right model for the document, and checking the output against the image.

For old documents, start with ATR-1. It is Leo's default model, at 1 credit an image: a Transformer trained on images of historical documents in the Latin alphabet, in any language that uses it. It weighs high-resolution visual evidence against context, and it is trained to transcribe what is on the page rather than normalise it: the long s stays a long s, the macron is not silently resolved, the archaic spelling survives, and strikethroughs, insertions and marginal notes are kept. It needs no per-collection training. It also checks its own output for failure patterns, such as a line repeated over and over: suspect output is hidden and retried, and if a job still can't succeed, the credit is refunded. The errors that do get through tend to be the recoverable kind, a wrong letter or word you can check against the image shown beside the text, not a fluent passage that was never on the page. And as users correct transcriptions in Leo, those corrections feed back into training, so the model improves with each release.

Alongside ATR-1, Leo has a model library: one menu in the transcription window, grouped by provider (Leo's own ATR-1, OpenAI, Google Gemini, Anthropic Claude), so the big general models are there when they suit the job. As a rough guide:

• Handwriting: ATR-1, built for the task and faithful to the page's spelling. On a hard page, run a general model as a second reading in its own tab.
• Early-modern print, Fraktur, newspapers, or anything you'll quote exactly: ATR-1
• Clean, legible modern print you just want to read: GPT-6 Luna or a conventional OCR engine, for a fraction of a credit

Each run goes into its own tab, so you can compare two readings of a hard page side by side. The Interpolate Transformation reconciles them into a best-fit reading. We compare the wider field in our comparison of handwriting transcription software.

Leo also keeps reading and processing separate. The base transcription stays faithful to the page. Transformations (translate, modernise, summarise and the rest) each write to a new tab and never overwrite the original. That is the safe version of what people want when they paste a manuscript into ChatGPT: the language model's fluency applied after the reading can be trusted, not instead of it. Whichever model you choose, the transcription is a draft for a person to check against the image, not an oracle.

The Judgment to Carry Back to the Archive

The deeper point outlasts any model or version number. A tool that generates fluent text will always give you fluent text, whether or not it could read the page, and fluent text is the hardest error to catch because it reads exactly like a correct transcription. The skill worth keeping sharp is the old one: knowing your hand (a free course in English secretary hand is a good place to start), knowing your abbreviations, and reading the machine's output against the image rather than instead of it. Whatever reads the page for you, the page is still the authority. Once you stop checking it, you have stopped doing history and started trusting a very confident guess.

Frequently Asked Questions

Can ChatGPT read handwriting?

Yes, for clear modern handwriting: ChatGPT usually transcribes a legible note or letter well. Historical handwriting is harder, and on old hands OpenAI's models have lagged in published tests. In the ChatGPT app the image is also downsampled before the model reads it, so fine marks such as a macron or a long s can be lost, and general models tend to quietly modernise old spelling. For old hands, use a model built for the task: Leo's ATR-1 reads the image at high resolution and is trained to transcribe what is on the page rather than normalise it. Whichever you use, check the reading against the image.

Why does ChatGPT make up words when reading old manuscripts?

It can, because it is a text generator at heart. Its decoder carries a strong learned sense of what English, French or Latin usually looks like, and when the visual evidence is thin that sense can fill the gap with a grammatical, period-appropriate reading that isn't on the page. That differs in kind from OCR and HTR errors, which tend to look wrong and are easy to spot. Newer general models invent less, but their commoner error is quieter: a more probable, modern spelling in place of the one on the page. Either way, the output gives no signal of which words were seen and which were guessed. Leo's ATR-1 is trained to keep the page's own spelling, and to hide and retry output that matches known failure patterns.

Does zooming in help ChatGPT read fine details on a manuscript?

Not much. The model never looks at your zoomed image directly. Vision-language models tile the image into patches and encode each within a fixed token budget; as OpenAI has described it, in high-detail mode an image is fitted inside a 2048×2048 envelope and split into 512×512 tiles. A densely written folio may have to fit a whole cluster of words into one tile, and anything finer than that is averaged into its neighbours before the language model reads a single token. In the ChatGPT app you also don't control the detail setting. Leo's ATR-1 reads the page at high resolution for exactly this reason.

Can I ask ChatGPT to correct its own transcription to improve accuracy?

It can make things worse. In one published benchmark (Crosilla, Klic and Colavizza, 2025), asking GPT-4o to correct its own transcription of historical Italian raised its character error rate from about 61% to 77%, as the model reasoned its way further from the page toward what "should" be there. A better prompt reduces this kind of drift but does not remove it. Checking against the image, or comparing two different models' readings and looking closely where they disagree, is more reliable than asking one model to mark its own work.

When is it safe to use ChatGPT with historical documents?

It is safe for work on a transcription you have already checked: translation, summary, a glossary of difficult terms, or a list of the people and places mentioned. For reading the image itself, choose the model for the document. For handwriting, and for anything you'll quote exactly, use a model built for historical documents, such as Leo's ATR-1. A small OpenAI model is good value on clean, legible modern print. Whichever you use, the page remains the authority: read the output against the image before you rely on it.

Is ChatGPT good for printed pages, like an old book?

For clean, legible print such as a 19th-century book or a typescript, a small OpenAI model reads the page well and very cheaply. In Leo, GPT-6 Luna costs 0.02 credits an image, a fraction of a US cent. Be more careful with early-modern type, Fraktur and newspapers. Small general models tend to modernise old spelling, and on a dense multi-column page they can stop partway through without saying so. For those, or anything you will quote exactly, use Leo's ATR-1, which keeps the long s and the spelling as printed, and compare the result with the image.