Home › Blog › VKT SnapOCR guides › OCR without uploading the image
EN中文日本語DeutschESFR

OCR Without Uploading the Image: How Local Recognition Works (2026)

Almost every OCR tool says it is private. The word costs nothing. What is not cheap, and what is checkable, is the architecture: whether the pixels ever leave, and whether the code could have sent them.

This is the version where they do not, and here is how that is actually built — the engine, the data files, the manifest, and the one network request that is a download rather than an upload.

What the claim has to mean

"No upload" is not one property but three, and they fail independently:

A tool can pass the marketing version of the claim and fail all three. So each of the three, in order.

The manifest is the contract

Manifest V3 forces an extension to declare what it wants to touch, and the browser shows that list to you on the store page. This is the whole list for a local OCR extension:

DeclaredWhat it is for
activeTabReach the tab you just acted on. Not all tabs, and not silently.
contextMenusAdd the right-click entry that starts the selector.
scriptingInject the region-selector overlay on demand.
storage + unlimitedStorageHand the cropped image to the result window; keep history and language choice.
clipboardWriteThe Copy button.
Host access: one entryThe extension's own licence endpoint. No site is in the list.

Two consequences worth sitting with. First, the screenshot comes from captureVisibleTab, which is a call for "the pixels currently on this screen" — it is not a fetch of the page's images, and it returns a data URL that stays in memory. Second, there is no host permission that could receive that data URL. A claim of privacy here is not a policy statement; it is a gap in what the code is allowed to do.

The manifest also states offline_enabled, and the content security policy for the extension's own pages is script-src 'self' 'wasm-unsafe-eval' — remote script is still refused, and the single added keyword is the wasm compile permission the bundled engine needs. That is what forces the engine to be packaged rather than loaded from a CDN.

The engine lives inside the extension

Recognition is Tesseract.js: the same LSTM engine that runs server-side OCR pipelines, compiled to WebAssembly so it can run in your browser process.

  1. The library, the worker script and the compiled core — the SIMD build when the CPU supports it, the plain build when it does not — are copied into the extension package at build time and loaded from chrome-extension:// URLs.
  2. The recognition itself runs in the extension's own result window, not in the page you captured. The page's scripts never see the image, and the image never sees the page's origin.
  3. Progress comes back through a logger callback that only drives the progress bar; there is no intermediate result to exfiltrate.

What this buys you is speed you can feel on small regions and a working tool on a plane. What it costs is cold-start time: unpacking a WebAssembly core and a language model is slower than a warm server, which is why a full-page capture takes a beat where a cloud call would not.

Two languages ship, seven download

Language data is the heavy part, and it is the one place where a network request exists by design.

Be precise about what that fetch is. It is a GET for a model file. Your capture is not in it, cannot be in it, and there is no host permission that would let it be. It is also the reason the Pro language list is not "fully offline" out of the box — offline starts after the first download, not before.

The path of one capture

End to end, with the network in the picture:

  1. You click the toolbar button or pick the menu entry; the overlay is injected into the tab you acted on.
  2. You drag a box. The rectangle is pure page coordinates — no image has been taken yet.
  3. The visible tab is captured as PNG. This is an in-browser call, not a download.
  4. The rectangle is cropped in the background worker with an off-screen canvas, scaled by the ratio between the captured bitmap and the viewport — so HiDPI and page zoom both land correctly, with devicePixelRatio only as the fallback when the viewport is missing. Local arithmetic on pixels you already owned.
  5. The result window opens, loads the bundled core and the bundled data file, and recognises. No request.
  6. The text appears in an editable box. Copy writes it to your clipboard; nothing is sent anywhere to do it.

Requests at steps 1–6: zero, for a bundled language. That is the property the rest of this post is about.

Where the text is kept

Two things are written to disk, both in the browser's own local storage area for the extension:

There is no account, so there is no profile to build. The cropped image itself is handed over through storage for the single step of opening the result window and is consumed on read; it is not an archive.

The one request that does leave

Network exists for exactly one purpose: licence validation. Opening a page asks the licensing endpoint whether the stored key is still active, and even that is throttled — inside a two-hour window the cached answer is used and no request is made. A missing key means zero requests, which is why the free path is not quietly phoning home.

If the endpoint is unreachable and a licence was cached, the extension keeps working rather than locking you out; the day's quota counter is deliberately local for the same reason. This is the trade every offline-first tool makes: the limits become cooperative rather than enforced, and in exchange the tool does not depend on a company's uptime to open a screenshot.

How to check any OCR tool

The same three questions work on any extension, ours or otherwise:

  1. Read the permissions block on the store page. Host access for "all sites", or a third-party API domain, tells you the architecture before you install.
  2. Pull the network. Recognise something with Wi-Fi off. Text means local; an error page means a server was in the loop.
  3. Ask what is retained. Look for a history list and a clear button in the extension's own UI. If history is only visible after login, it is on their disk, not yours.

One caveat so this does not oversell: local means your machine still has to be yours. A managed work browser with endpoint agents, or a browser extension combined with a screenshot-sync tool, changes the picture entirely — the OCR being local says nothing about what else is watching the screen.

FAQ

Does OCR in a browser extension need any internet connection at all?

Not for the two bundled languages. The engine, its WebAssembly core and the English and Simplified Chinese data files are packaged inside the extension, so recognition completes with the network unplugged. A non-bundled language needs one download of its data pack the first time you choose it.

Can I check for myself that nothing is uploaded?

Yes, in two ways. Open the extension's detail page in the browser and read its permissions and host accesses: anything that could post your image would have to appear there as a host permission. Then run a recognition with the network disabled. If text still comes back, the read happened locally.

Why does the free daily counter live on my machine instead of a server?

A server-side counter would lock you out whenever the network is unavailable, which contradicts an offline promise. The cost of the local choice is that the limit is an honest-use boundary rather than a hard defence, and that the counter resets on your own calendar day, not on UTC midnight.

Is WebAssembly OCR as good as a cloud service?

For clean screenshots of real typography, they are close, because both use the same class of LSTM models and the same public trained data. Cloud services pull ahead on photos with perspective distortion, handwriting and layout analysis of whole documents. A screen capture is the easy case, which is why a local engine is a reasonable trade here.

More guides in the VKT blog; questions to support@annmax1983.com.

Keep reading

How to Copy Text from an Image in Chrome (2026)
SnapOCR Free vs Pro: What the Licence Actually Unlocks (2026)
All VKT SnapOCR guides