Your files never leave your device. All processing happens locally in your browser.
How do I calculate a file’s MD5 or SHA-256 checksum without uploading it?
Open the File Hash Calculator, drop one or more files onto it (or click to browse, paste a file URL to fetch, or type raw text), pick the algorithms you want — MD5, SHA-1, SHA-256, SHA-384, SHA-512 or CRC32 — and it streams every file through the hash functions on your device and prints each checksum, with no upload. A cryptographic hash is a fixed-length fingerprint of a file’s exact bytes: change a single bit and the output changes completely, so a matching hash proves a download is intact and unaltered. All the algorithms you select are computed in one streamed pass — SHA-1/256/384/512 run on the browser’s native Web Crypto engine, while MD5 and CRC32 use built-in streaming implementations — and you can copy any value, switch the output to lowercase hex, uppercase HEX or Base64, and export a checksums.txt, a JSON report or a GNU-style per-algorithm manifest (checksums.sha256, checksums.md5, …). Paste a known hash or a whole checksums manifest into the Verify box and it auto-detects the algorithm by length and flags each file as a match or a mismatch. Everything runs in your browser, so the files never leave your machine.
Hash any file with MD5, SHA-1, SHA-256, SHA-384, SHA-512 or CRC32 — several at once, in a single streamed pass
Add files by drag & drop, the file picker, a CORS-enabled URL fetch, or by typing text
Verify against a pasted hash or a full checksums manifest — the algorithm is auto-detected by length (8 / 32 / 40 / 64 / 96 / 128 hex chars)
Output as lowercase hex, uppercase HEX or Base64; export checksums.txt, a JSON report or a GNU-style per-algorithm manifest
100% client-side — files are read and hashed in the browser and never uploaded
What is
File Hash Calculator
A file hash calculator computes a checksum — a fixed-length hexadecimal fingerprint — from the exact bytes of a file using a cryptographic hash function such as MD5, SHA-1 or SHA-256. A hash function is deterministic and one-way: the same file always yields the same digest, any change (even a single bit) produces a completely different digest through the avalanche effect, and the original data cannot be recovered from the hash. This makes checksums the standard way to verify file integrity — confirming a downloaded ISO, installer, backup or attachment is byte-for-byte identical to what the publisher released and was not corrupted in transit or tampered with — and to detect duplicate files. Output length is fixed per algorithm: MD5 is 128-bit (32 hex characters), SHA-1 is 160-bit (40), SHA-256 is 256-bit (64), SHA-384 is 384-bit (96) and SHA-512 is 512-bit (128); CRC32 (8 hex characters) is a non-cryptographic checksum used by gzip, zip and PNG for accidental-corruption detection only. MD5 and SHA-1 are cryptographically broken — collisions can be engineered — so for security you should compare SHA-256 or stronger, though MD5 and CRC32 remain fine for spotting accidental corruption and duplicates. This tool runs entirely in the browser, streaming each file through the hash functions with no upload, server or account.
No. Each file is read and hashed entirely in your browser — there is no upload, server or account, so the bytes never leave your device.
Nothing is uploaded. When you drop, browse, fetch or type input, the tool reads it locally with the browser’s File API and computes the hash in memory on your device, streaming the file in 4 MB chunks so even multi-gigabyte files do not freeze the tab. The strong algorithms (SHA-1, SHA-256, SHA-384, SHA-512) run on the browser’s built-in Web Crypto engine, and MD5 and CRC32 use bundled JavaScript implementations; there is no server, API, database or tracking in the processing path, so a private document, disk image or key file stays on your machine. The tool works offline once cached, and closing the tab discards everything. The one case where data touches the network is if you paste a remote URL for the tool to fetch, and even then the response is downloaded straight into your browser and hashed there, never sent anywhere else. The only optional network use anywhere on the site is consent-gated advertising, which never sees your file.
Use SHA-256 (or SHA-512) for security and to verify downloads; MD5, SHA-1 and CRC32 are fine only for spotting accidental corruption or duplicates.
For anything security-related — confirming a download was not tampered with, matching a publisher’s checksum, or comparing files you do not fully trust — use SHA-256, which is the modern default, or SHA-512 if a project publishes that. MD5 and SHA-1 are cryptographically broken: researchers can craft two different files with the same MD5 or SHA-1 digest, so a match no longer guarantees the file is genuine. They are still perfectly useful for detecting accidental corruption, deduplicating files, or matching a legacy checksum that was only ever published in MD5. CRC32 is not a cryptographic hash at all — it is a fast error-detecting code used inside gzip, zip and PNG — so use it only to catch random bit-flips, never for security. This tool lets you compute several at once, so you can generate SHA-256 for trust and MD5 for a legacy manifest in the same pass.
Hash the file, then paste the publisher’s expected hash (or their whole checksums manifest) into the Verify box — it auto-detects the algorithm and shows Match or Mismatch.
Add the downloaded file so it is hashed, then copy the checksum the publisher lists next to the download and paste it into the Verify box. The tool detects which algorithm it is from the string length — 32 hex characters means MD5, 40 means SHA-1, 64 means SHA-256, 96 means SHA-384, 128 means SHA-512 and 8 means CRC32 — compares it against the matching computed digest, and shows a green Match or a red Mismatch for each file. You can also paste an entire GNU-style checksums manifest (one “hash filename” line per file, as produced by sha256sum), and it will line up every listed hash against the queued files by name and report each row. A Match means the file is byte-for-byte what the publisher released; a Mismatch means it was corrupted in transit or altered, and you should re-download it.
Yes — files are streamed in 4 MB chunks so large files stay responsive, and you can also hash pasted text or fetch a file from a CORS-enabled URL.
The calculator reads each file in 4 MB slices and updates the streaming hashers chunk by chunk, yielding to the browser between chunks so the interface keeps a live progress bar and the tab does not lock up even on multi-gigabyte disk images or videos; it also reports elapsed time and throughput. Besides local files you can hash text — type or paste any string and it is hashed as a UTF-8 blob, handy for checking a snippet against a known digest — or paste a URL and the tool fetches the file into the browser and hashes it there, provided the remote server allows cross-origin requests (CORS); if it does not, you get a clear message rather than a silent failure. You can queue many files at once; they are processed one at a time so memory stays under control, and results, copies and exports update as each finishes.
Detailed Explanation
📖How It Works
Calculating File Checksums in Your Browser
The File Hash Calculator computes a cryptographic checksum for any file without uploading it. Drop one or more files, click to browse, fetch a file from a URL, or type raw text, choose from MD5, SHA-1, SHA-256, SHA-384, SHA-512 and CRC32, and it streams each file through the selected hash functions on your device and prints every digest. A hash is a fixed-length fingerprint of a file’s exact bytes: the same file always produces the same value, and changing a single bit changes the output completely (the avalanche effect), which is why a matching hash proves a download is intact and unaltered. All selected algorithms are computed in a single streamed pass — SHA-1/256/384/512 on the browser’s native Web Crypto engine and MD5 and CRC32 via bundled streaming implementations — and results appear with elapsed time and throughput. Everything runs locally in JavaScript, so private disk images, backups, keys and documents never leave the machine.
Six algorithms: MD5, SHA-1, SHA-256, SHA-384, SHA-512 and CRC32, computed together in one pass
Add files by drag & drop, the picker, a CORS-enabled URL fetch, or typed text
A hash is a fixed-length fingerprint; one changed bit changes the whole digest
100% client-side — nothing is uploaded to any server
📋Use Cases
Verifying Downloads and Detecting Tampering
The main reason to hash a file is integrity verification. When a project publishes a download it usually lists a SHA-256 (sometimes MD5) checksum next to it; after downloading, you hash your copy and compare. This tool makes that a paste: add the file so it is hashed, then paste the publisher’s expected hash into the Verify box and it auto-detects the algorithm by length — 32 hex chars is MD5, 40 SHA-1, 64 SHA-256, 96 SHA-384, 128 SHA-512, 8 CRC32 — and shows a green Match or red Mismatch. It also accepts an entire GNU-style checksums manifest (one “hash filename” line each, as produced by sha256sum) and lines every listed hash up against the queued files by name. A Match means the file is byte-for-byte what was released; a Mismatch means it was corrupted in transit or altered and should be re-downloaded. The same workflow deduplicates files (identical content yields identical hashes) and lets you record a checksum now to prove a file is unchanged later.
Verify a download against a publisher’s hash, with the algorithm auto-detected by length
Paste a whole sha256sum-style manifest to check many files at once by name
Match = byte-for-byte identical; Mismatch = corrupted or tampered, re-download
Also used to find duplicate files and to record a checksum for later re-checks
🔧Technical Details
Streaming Engine, Web Crypto and Exports
Hashing runs entirely client-side. Each file is read with the browser’s File API and sliced into 4 MB chunks; every chunk feeds the streaming MD5 and CRC32 implementations directly and is accumulated for the Web Crypto digests, with the event loop yielded between chunks so a live progress bar keeps updating and the tab stays responsive on multi-gigabyte inputs. SHA-1, SHA-256, SHA-384 and SHA-512 use the browser’s native, hardware-accelerated crypto.subtle.digest; MD5 (RFC 1321) and CRC32 (the IEEE polynomial used by gzip, zip and PNG) are implemented as chunk-fed streaming classes because Web Crypto omits them. Output can be shown as lowercase hex, uppercase HEX or Base64. Exports match command-line conventions: a combined checksums.txt, a structured JSON report, and per-algorithm manifests named checksums.sha256, checksums.md5 and so on in the exact “hash filename” format that sha256sum -c and md5sum -c consume. Files are queued and processed one at a time so peak memory stays bounded, and toggling algorithms after a run offers a one-click re-hash.
Files streamed in 4 MB chunks with the UI yielded between chunks for responsiveness
SHA family via native Web Crypto (crypto.subtle.digest); MD5 (RFC 1321) and CRC32 hand-written streaming
Output as lowercase hex, uppercase HEX or Base64
Exports checksums.txt, JSON, and per-algorithm manifests compatible with sha256sum -c / md5sum -c
⚠️Limitations
Honest Limitations
A hash verifies integrity, not authenticity on its own: it only proves a file matches a given checksum, so that checksum must come from a trusted source (ideally over HTTPS, or signed) — an attacker who can replace the download can often replace the posted hash too, which is why serious projects also sign their checksum files. Algorithm choice matters: MD5 and SHA-1 are cryptographically broken (practical collisions exist), so a match no longer guarantees a file is genuine; use them only for accidental-corruption or duplicate detection and compare SHA-256 or stronger for anything security-sensitive. CRC32 is not cryptographic at all — it is an error-detecting code, trivial to forge — and suits only random bit-flip detection. Practically, computing several strong hashes over a very large file is CPU- and memory-bound in the browser, so huge inputs take time and can strain low-memory devices; a native tool like sha256sum will be faster on multi-gigabyte files. Loading a file from a remote URL only works when that server sends permissive CORS headers, otherwise the fetch fails with a clear message rather than silently.
A hash proves integrity only if the reference checksum comes from a trusted, ideally signed source
MD5 and SHA-1 are broken (collisions exist); use SHA-256+ for security
CRC32 is a non-cryptographic error check, trivial to forge
Very large files are CPU/memory-bound in-browser; remote-URL loading needs permissive CORS
🔒Privacy & Security
Privacy: Your Files Stay on Your Device
The files you hash are often exactly the ones you should not upload — disk images, database backups, private keys, identity documents or proprietary builds — and this tool is built so they never leave your machine. Each file is read with the browser’s File API and hashed entirely in memory: the strong algorithms run on the browser’s native Web Crypto engine and MD5 and CRC32 in bundled JavaScript, with no server, upload, database, logging, API or CDN anywhere in the processing path. The tool works offline once cached, and closing the tab discards everything. The only moment anything touches the network is if you explicitly paste a remote URL for the tool to fetch, and even then the response is downloaded straight into your browser and hashed there, sent nowhere else. The only optional network use anywhere on the site is consent-gated advertising, which never sees your file or its contents.
Read and hashed entirely in the browser — strong algorithms on native Web Crypto
No server, upload, database, API or CDN in the processing path
Works offline once cached; closing the tab discards everything
Only optional network use is consent-gated ads, which never see your file
File Hash Calculator — algorithms, features and limits
Capability
Support
Notes
Algorithms
MD5, SHA-1, SHA-256, SHA-384, SHA-512, CRC32
Several at once in one streamed pass; SHA family via native Web Crypto
Inputs
Drag & drop, picker, CORS-enabled URL fetch, typed text
Any file type, any size; text is hashed as a UTF-8 blob; URL fetch needs CORS
Verify
Paste a hash or a full sha256sum-style manifest
Algorithm auto-detected by length; per-file Match / Mismatch verdict
Output
Lowercase hex, uppercase HEX or Base64
Copy any digest; switch format without re-hashing
Export
checksums.txt, JSON, per-algorithm manifest
Manifests compatible with sha256sum -c / md5sum -c
Security
SHA-256+ for trust; MD5 / SHA-1 / CRC32 for corruption only
MD5 and SHA-1 have practical collisions; CRC32 is non-cryptographic
The calculator reads each file with the browser File API in 4 MB chunks and computes MD5, SHA-1, SHA-256, SHA-384, SHA-512 and CRC32 in a single streamed pass — SHA family on native Web Crypto, MD5 (RFC 1321) and CRC32 hand-written — showing progress, time and throughput. Output can be lowercase hex, uppercase HEX or Base64, and results export as checksums.txt, JSON or per-algorithm sha256sum-style manifests. A Verify box checks a file against a pasted hash or manifest, auto-detecting the algorithm by length. MD5 and SHA-1 are cryptographically broken, so compare SHA-256 or stronger for security; a reference checksum must come from a trusted source; and remote-URL loading needs permissive CORS. Everything runs in the browser; nothing is uploaded.