You bought a 256 GB microSD card for your dashcam. It worked fine for a week, then you found corrupted video files and missing footage from the days you needed most. The card was not 256 GB. It was a smaller chip with rewired firmware that reported a larger size to your operating system, silently overwriting your oldest files once you passed the real limit. This article shows you how to catch fake and underperforming storage before you lose data, using browser tools for what they can test and native tools for what they cannot.
How fake storage silently corrupts your data
Counterfeit cards combine a small real chip, often 8 GB or 16 GB, with controller firmware that reports a larger capacity to the operating system. When you write files past the real limit, the card does not throw an error or refuse the data. It loops back to the beginning of the address space and overwrites your earliest files without any warning. The result is a card that appears to hold your data but has been quietly destroying it from the moment you exceeded its actual capacity.1
A quick “copy a file, it works” test proves nothing because corruption only appears after you exceed the real capacity, and by then the card has already started overwriting the data you wrote first. As TP-Link’s fake SD card identification guide explains, counterfeit cards combine a reprogrammed controller with whatever small NAND chip was cheapest that month, and the operating system believes every byte of the lie. The operating system sees the fake size the firmware reports, so every file manager, disk utility, and properties dialog lies to you about how much space is available. The only reliable way to detect this fraud is to write data past the claimed limit and then read it back to verify every byte survived.
| Behavior | Genuine card | Counterfeit card |
|---|---|---|
| Capacity reporting | Matches physical chip exactly | Firmware reports more than the physical chip holds |
| Write behavior past the limit | Refuses with a write error | Silently overwrites the oldest data |
| Corruption pattern | None; writes fail cleanly | Files at the start of the address space get destroyed |
| How to detect | Not applicable | Write past capacity, read back, compare hashes |
What you can verify in a browser
Browsers cannot access raw block devices, so direct speed benchmarking and exact capacity measurement are impossible from a web page. The sandbox that keeps you safe from malicious sites also prevents a browser from issuing low-level SCSI or NVMe commands to your storage hardware. This is a hard limitation, not a missing feature, and no amount of JavaScript can work around it.2
But you can verify file integrity using cryptographic hashes via the File API, which catches the most dangerous failure mode counterfeit cards produce: silent data corruption. When you compute a SHA-256 hash of a file before writing it to a card and then hash the copy you read back, any mismatch tells you the card altered your data. This is where CapyToolkit’s File Hash Verifier fits into a storage testing workflow, alongside other browser-based utilities that run entirely in your browser. It computes four hash algorithms simultaneously on files you select, processing them in 2 MB chunks so even multi-gigabyte video files verify without exhausting your browser’s memory.
A browser-based verification workflow
A two-part workflow catches the most common storage fraud and costs nothing but time. First, verify what you write to the card so you know the source file is intact. Then verify what you read back so you know the card preserved it. Together these steps expose fake capacity and silent corruption without requiring a single native application, and they work identically for microSD cards, full-size SD cards, and external USB or NVMe SSDs.
Verify the source image before writing
When you download a firmware or OS image, a Raspberry Pi boot image, a dashcam update, or a drone flight controller file, verify its hash before you write it to a card. A corrupted image written to a card can brick a device or cause erratic behavior that takes hours to diagnose, and the symptoms, random reboots, frozen boot screens, storage errors, often look like hardware failure rather than a bad flash. Compute the SHA-256 hash with the File Hash Verifier and compare it to the publisher’s checksum. If the hashes do not match, your download is incomplete or tampered with, and you should re-download before flashing anything. This step applies to ISO downloads you are about to flash and to firmware archives you plan to install, where a single flipped bit in a bootloader or partition table can turn a card and the device it goes into an expensive paperweight.
Round-trip copy test for fake capacity
Copy a known set of files to the card until it is at least 75 percent full, then copy them back to a folder on your computer. The 75 percent threshold matters because many counterfeit cards use 8 GB or 16 GB chips sold as 64 GB or 128 GB, and a test that only fills 10 percent of the claimed capacity will stay entirely within the real chip and miss the overwrite behavior completely.3 Hash the originals and the copies with the File Hash Verifier. Mismatches reveal fake capacity because the card silently overwrote data past its real limit during the write phase, so the copy you read back differs from what you put in. Use varied file sizes, small documents alongside large video files, to stress different write patterns across the card’s address space. A mix of 1 MB, 50 MB, and 500 MB files exercises both the small-block and large-block write paths that the controller handles differently. This tests integrity, not speed. The goal is to confirm that every byte you wrote can be read back unchanged, which is the one thing a counterfeit card cannot fake.
Interpret the results
All hashes match: the card holds data reliably for the tested capacity. You have not proven it is genuine beyond the amount you wrote, but you have proven it does not silently corrupt data within the range you tested. For a dashcam or backup use case, that is often enough confidence to put the card into service. Mismatches: the card is fake or defective. Return it immediately. Do not attempt to reformat it and keep using it, because the same overwrite behavior will recur once you pass the real limit again, and no amount of partitioning or formatting changes the physical size of the chip inside. Partial or intermittent matches: weak flash blocks or a failing controller. This pattern is especially dangerous because the card appears to work most of the time, so you trust it with important data and only discover the problem when a file you need fails to open. Monitor closely or return. Document the failures for the return claim, noting which specific files produced mismatches, at what capacity the errors began, and whether the failures were consistent or random across multiple test runs.
What browser tools cannot test and what to use instead
Raw sequential and random read-write speed require native tools such as CrystalDiskMark on Windows, hdparm on Linux, or Blackmagic Disk Speed Test on macOS. These tools issue direct block-device commands that browsers cannot reach, and they measure the sustained throughput your camera or drone needs for reliable recording. CrystalDiskMark runs a standard suite of sequential and random tests and reports both read and write speeds, so you can compare the results against the ratings printed on the card. Blackmagic serves a similar purpose on macOS with a straightforward pass-fail indicator for common video formats. hdparm gives Linux users a quick sequential read check from the terminal, though it only tests reads, not writes.4
Real capacity with full write-verify requires H2testw on Windows or f3 and f3probe on Linux and macOS, the Fight Flash Fraud tools that write patterns across the entire card and read them back to confirm every address holds data correctly. As the LinuxLinks overview of f3 describes, these utilities test the real size of the media and compare it against what the drive reports, exposing the gap between the firmware’s claim and the physical silicon. H2testw writes a series of test files that fill the full claimed capacity, then reads each one back and verifies the content, reporting exactly where any corruption begins.5 f3 on Linux and macOS performs the same write-and-verify cycle, while f3probe goes further by probing the card to discover its true capacity even when the firmware lies about the size.6 These tools remain the definitive answer for capacity verification, and they are the right choice when you need to be absolutely certain before trusting a card with irreplaceable data.
Reach for native tools when you need exact speed numbers for a device that requires a minimum sustained write speed, such as a 4K camera that demands a V60 card, or when a browser hash test has already flagged a card and you want a full write-verify to document the failure for a return claim. Browser integrity testing is enough when your main concern is data integrity for dashcams, backups, or general file storage. In those cases, the round-trip hash test catches the failure mode that actually costs you data, which is silent corruption from a counterfeit or degrading card.
What the specs actually mean when buying storage
Storage specs are marketing-heavy, and a few numbers actually predict real-world performance. Learning to read the label separates a card that records 4K video without dropping frames from one that promises the same thing on the box and fails in the field.
Speed classes and ratings
Speed Class covers the oldest ratings: C2, C4, C6, and C10, guaranteeing minimum sustained write speeds of 2 MB/s up to 10 MB/s. UHS Speed Class adds U1 and U3, guaranteeing 10 MB/s and 30 MB/s respectively. Video Speed Class runs from V6 through V90, mapping directly to the sustained throughput needed for standard video up to 8K recording. Application Performance class, A1 and A2, governs random read and write IOPS for running apps directly from the card.7 Each rating guarantees a minimum sustained write speed, which matters far more for video recording than the peak read speed that boxes emphasize in large print. The SD Association maintains the official speed class specifications that define each rating and the testing conditions they certify.
| Rating | Minimum sustained write | Typical use case |
|---|---|---|
C10 | 10 MB/s | Full HD video, general storage |
U1 | 10 MB/s | Full HD video on UHS-I bus |
U3 | 30 MB/s | 4K video at standard frame rates |
V30 | 30 MB/s | 4K video, the most common “4K ready” rating |
V60 | 60 MB/s | 4K high frame rate, 8K at lower rates |
V90 | 90 MB/s | 8K video, professional cinema recording |
A1 | 1500 read / 500 write IOPS | Running apps, light multitasking |
A2 | 4000 read / 2000 write IOPS | Running apps with heavier workloads |
Capacity, endurance, and the card reader
The cheapest card per gigabyte is usually the most expensive mistake you can make. No-name brands, old stock, and counterfeits cluster at the bottom of the price range, and the savings of a few dollars evaporate the first time you lose footage or have to replace a failed card. TBW, terabytes written, and endurance ratings matter for dashcams and write-heavy use because those applications constantly overwrite the same blocks, wearing the flash memory down over time. A card rated for higher endurance lasts longer in these conditions before blocks start failing.
A card reader’s quality affects both speed testing and real-world transfers, and a bad reader bottlenecks a good card. A USB 2.0 reader caps you at roughly 35 MB/s regardless of the card’s actual capability, and a poorly designed reader can introduce errors that look like card failures during testing.8 Buy from reputable sellers, sold and shipped by a major retailer rather than a third-party marketplace, to reduce counterfeit risk. Counterfeit cards frequently appear in marketplace listings where the seller changes names and the product photos match the genuine article but the chip inside does not.
If you are looking for a reliable card to test with, the Lexar PLAY 256GB microSDXC delivers solid real-world performance at a price that makes it a reasonable testing spare. It reads at up to 150MB/s, carries the U3, V30, and A2 ratings needed for 4K video, and its low cost means you can buy one purely for hash-verification and capacity testing without worrying about sacrificing a primary storage card to the process.
When a card fails testing and what to do about it
Any hash mismatch means return the card immediately. Do not try to live with a card that fails intermittently, because the failure will recur and worsen as the flash blocks degrade further. A card that passes today but shows even a single mismatch is a card that will fail again under slightly different conditions, and you should treat the first failure as the final verdict.
When documenting the failure for a return, gather the following evidence before you ship anything back. Sellers of counterfeit cards rely on buyers who cannot prove the defect, so a well-documented claim is the difference between a full refund and a rejected return:
- Screenshots of the hash mismatch from the File Hash Verifier, showing the expected and computed checksums side by side
- The specific files that failed and the exact error or corruption observed when you tried to open them
- The test conditions: how full the card was when errors appeared, what file types you used, and whether the card was fresh out of the package or had been in use
- The purchase receipt and product listing, which establish what capacity and speed you paid for
If the card passed browser integrity testing but you still suspect issues, run H2testw or f3 for a definitive capacity and write-verify answer. These native tools write across the entire card and catch edge cases a partial round-trip test might miss, giving you a complete answer before the return window closes.
- 1.
MDRepairs, “Fake Hard Drives: How to Spot Them Before You Lose Data,” mdrepairs.com, accessed August 2026. https://mdrepairs.com/blog/fake-hard-drives-how-to-spot/
- 2.
Mozilla Developer Network, “File System API,” developer.mozilla.org, accessed August 2026. https://developer.mozilla.org/en-US/docs/Web/API/File_System_API
- 3.
Gecko & Fly, “12 Freeware To Detect Fake USB Flash Drives, SSD Drive, & SD Cards,” geckoandfly.com, accessed August 2026. https://www.geckoandfly.com/22803/detect-fake-usb-flash-drives-sd-cards-ssd-disk/
- 4.
“hdparm,” Wikipedia, accessed August 2026. https://en.wikipedia.org/wiki/Hdparm
- 5.
Philip Seeger, “h2testw (CapacityTester),” GitHub, accessed August 2026. https://github.com/Kris-85/h2testw/blob/master/README.md
- 6.
AltraMayor, “F3 - Fight Flash Fraud,” GitHub, accessed August 2026. https://github.com/AltraMayor/f3
- 7.
ADATA, “How to choose a memory card for dash cams? A complete guide to memory card specification and maintenance tips,” adata.com, December 2025. https://www.adata.com/global/quikTips/choose-memory-card-for-dash-cam-specs-guide/
- 8.
“USB,” Wikipedia, accessed August 2026. https://en.wikipedia.org/wiki/USB
