How durable are today’s microSD cards? How well do they perform? I’m testing a bunch of them to find out.

Or: What are the best microSD cards you can get for under $15 in 2024?

If you just want to see my top picks, skip to the Overall Picks section. If you want to read in more detail about how I determined the top picks, read on.

Table of Contents

Introduction

MicroSD cards are ubiquitous nowadays, having found applications in a wide variety of consumer devices — including smartphones, digital cameras, and single-board computers. While innovation is continuing to take place in this space, the market has largely matured. There are a wide variety of brands, models, and capacities available today, but it could be argued that consumers see little difference — aside from capacity — from one brand or model of card to the next. This ubiquity has helped to drive prices down to the point where a card able to store hundreds of gigabytes of data can be obtained for less than the price of a single meal at an average restaurant.

As with any popular product, the market is littered with fakes. For example, 1 terabyte microSD cards from major brands — such as SanDisk or Lexar — cost around $70-$100, depending on the specific brand or model. A cursory search on Amazon for a 1 TB microSD card, however, yields off-brand (or no-brand) cards with prices as low as $12.99. How are these brands able to offer their products for far less than their name-brand competitors? In many cases, these cards are what is known as “fake flash” — cards that have been programmed to advertise a certain capacity to their host device, but whose actual capacity is far less. For example, a card advertised as having a capacity of 1 terabyte might have an actual capacity closer to 8 gigabytes. On these cards, the actual storage space is typically located at the beginning of the card’s logical address space; writes that occur beyond the end of the available space are simply discarded, while reads will typically result in all zeroes. Additionally, most filesystem implementations will fill up the available space in a linear fashion. Altogether, this means that the user might not notice anything wrong until they’ve filled the card’s physical space — at which point they will find that the data that was saved beyond the end of the card’s physical space is simply gone and unrecoverable.

Fake flash is not completely worthless, however. If the true amount of physical space can be determined, the card’s partition table can be adjusted so that filesystems do not take up more than the amount of physical space available on the card. But, how well do these cards perform — in terms of performance and durability — compared to their “legitimate” counterparts? Is there value in buying fake flash if the caveat on the amount of available space is known beforehand? This was the question that I sought to answer.

In July 2023, I began purchasing various brands and capacities of microSD cards, and I’ve been testing them continuously since then. Originally I turned to AliExpress, focusing primarily on the cheapest options I could find; however, I’ve since expanded my collection to include some name-brand media as well. I also purchased some name-brand media from Amazon — not only because I was curious to see how they performed as well, but also to act as a sort of baseline for comparison.

On this page, I’m listing the results I’ve obtained so far. Keep in mind that many of the cards I purchased are still undergoing testing, and others are still sitting in the packaging waiting to be tested — I’ll note those in my results and update them once I have results to share.

Disclaimer: These tests are not being sponsored by anyone other than myself. All equipment and materials used have been paid for out of my own pocket. I’ll update this if this ever changes.

Criteria

For each card I purchased, I wanted to be able to answer the following questions:

Authenticity: Is the card the size it says it is, or is it fake flash?
Performance: How well does the card perform in reading and writing operations? Does the card perform well enough to merit the various speed class markings that appear on the card or the card’s packaging?
Endurance: How much data can be written to the card before the card becomes unreliable or fails completely?

Authenticity

On the authenticity front, I’m primarily concerned with whether or not a card is “fake flash”. For the purposes of this survey, I’m defining “fake flash” to mean “(a) SD media whose physical capacity is less than what is advertised to the host via its CSD register, or (b) SD media whose physical capacity is less than 95% of what is printed on the card’s exterior or the product packaging”. (I don’t have a method for determining whether a card has a capacity that is more than what is advertised…yet.)

As a secondary concern, I’m also going to be evaluating whether a card can be considered “skimpy flash”. For the purposes of this survey, I’m defining “skimpy flash” to mean “any flash media whose physical capacity — as advertised to the host via its CSD register — is less than what is printed on the card’s exterior or the product packaging”. And, for the purposes of this survey, sizes will be evaluated using linear scales — that is, 1 terabyte = 1,000,000,000,000 bytes, 1 gigabyte = 1,000,000,000 bytes, and so on. For example, if a card is labelled as being 32GB in size, does it actually have at least 32,000,000,000 bytes of available space, or does it have something closer to 31,500,000,000 bytes of available space?

Why include this criteria? Because it can have a material effect on a user’s experience with a card. Skimpy flash is a problem with name-brand and off-brand media alike — with a couple particular name-brands actually being the worst offenders in my survey (so far). (That said, there are a couple other name-brands that were actually the least offenders as well.) Consider, for example, two 64GB cards I obtained — one from Kioxia (the company formed as a result of Toshiba spinning off their flash memory division in 2018) that had a capacity of about 61.89GB, and one from Lexar that had a capacity of about 64.09GB. This is a difference of almost 2.2GB — or about 18 minutes of 1080p video (at 16Mbps).

Edit 3/13/2024: Some cards support a certain amount of password-protected storage. This feature is known as “CPRM”. I realized that, according to the SD Physical Layer Specification, “Card Capacity means the sum of User Area Capacity and Protected Area Capacity” — and I hadn’t been considering the size of the protected area in my skimp calculations. Going forward, I’ll include skimp measurements in the details section for each card. However, since accessing the protected area generally requires special hardware and software support, and most people don’t use it anyways, I’m not going to include it in the overall results. In addition, some cards indicate that they have a non-zero amount of protected memory, but also don’t support card security — and according to the SD Physical Layer Specification, “[f]or Non CPRM Cards, the Protected Area cannot be accessed.” For these cards, I will note that the protected area is inaccessible and will not provide an adjusted skimp calculation.

Performance

The SD Association has created a number of performance standards for SD cards, each with their own mark. Virtually all SD and microSD cards sold today carry at least one of these marks. I’m concerned with how well cards performed overall, but I’m also concerned with whether or not the card performed well enough to qualify for the markings that it bears — both on the packaging and on the card itself.

As of today, the SD Association has defined the following speed classes:

Class 2, 4, 6, 10: These speed classes dictate that read and write speeds should be at least 2MB/sec, 4MB/sec, 6MB/sec, and 10MB/sec, respectively. Cards have an application unit (AU) size defined in their SSR register, and write performance is measured by the amount of time taken to write in a sequential fashion to a single AU. (In the case of SDXC and SDUC cards, write performance is measured over a single AU or a 4MB segment of an AU, whichever is smaller.) Read performance, on the other hand, is measured by the amount of time taken to perform 256 random read operations.
U1 and U3: These speed classes dictate that read and write speeds should be at least 10MB/sec and 30MB/sec, respectively, when operating in UHS-I or UHS-II mode. The semantics of how performance is measured is largely the same as for Class 2/4/6/10.
Video Speed Class 6, 10, 30, 60, and 90: Version 5 of the SD card specification added a set of video speed classes, as well as some new commands to control the operation of the card and place the card into Video Speed Class recording mode. When operating in this mode, these speed classes dictate that write speeds should be at least 6MB/sec, 10MB/sec, 30MB/sec, 60MB/sec, and 90MB/sec, respectively.
Application Performance Class 1 and 2: These speed classes dictate a minimum number of random read and write operations per second (where each operation is 4KB in size), as well as a minimum sequential read and write speed of 10MB/sec. Application Performance Class 1 dictates a minimum of 1500 read operations per second and 500 write operations per second, while Application Performance Class 2 dictates a minimum of 4,000 read operations per second and 2,000 write operations per second.

Realistically, I don’t have the ability to perform tests exactly as the SD specification prescribes (although I’m working on that), so I’ve tried to engineer tests that at least approximate the spirit of the test. Many of the cards I tested performed far beyond what would have been required for the speed class markings they carried, while others fell far short of them. Others fell into a gray area, where they came close to the thresholds needed to qualify for one or more speed class markings, but technically fell short — and until such time as I’m able to test them properly, I’m willing to concede that they might have qualified for a particular speed class marking had they been tested under the right conditions. I’ll note these in my results.

Endurance

This one is pretty simple: how long will the card last if we write to every available byte on the card? Flash media has a tendency to degrade and become less reliable the more it’s written to, so I’m interested in seeing not only how many times we can write to the card before data errors start cropping up, but also how many times we can write to the card before it becomes completely unusable. I’m not sure there’s a standard here — at least, the SD specification doesn’t seem to define one — but I’ve seen things online indicating that 2,000 write cycles seems to be a reasonable expectation, so I’m going with that. Specifically, I want to see whether a card can reliably store data across at least 2,000 read/write cycles. Flash media isn’t perfect — some data errors are bound to occur even before the card has hit the 2,000 write cycle mark — so some allowance will be made for data errors that occur early on, as long as the error does not recur shortly afterwards.

Methodology

I had originally intended to use a combination of f3 and stressdisk to perform these tests; however, after finding some shortcomings to both tools, I decided to write a single tool that would combine the functionalities of both. I’ve made the source code available on GitHub.

Admittedly, these tests have not been completely scientific in nature, despite my desire to do so — for example:

I’ve been making code fixes to my tool as the project has gone on, and different cards were tested by the different versions of the program (or multiple versions of the program).
I’m using multiple different models/brands of SD card reader (although I’m in the process of trying to migrate to a single model).
I’m using two different PCs that are running two different versions of Ubuntu.

But, the general strategy I took is described in the following sections.

All of these tests were run on x86_64 PCs running Ubuntu. SD cards are connected to SD card readers, which are attached to the system via USB. The device is opened with the O_DIRECT and O_SYNC flags to try to minimize the effects of caching by the system.

Authenticity

The logical space on the card (not including the Protected Area, if any) is divided into eight equal or near-equal segments. The length of each segment is determined by taking the total number of sectors on the card and dividing by eight. (Side note: Linux always considers a sector to be 512 bytes, regardless of the physical size of the sector on the device.) A starting sector is then chosen in each segment:

In the first segment, the starting sector is always sector 0.
In the last segment, a random starting sector is chosen such that is at most 8MB from the end of the device. (Note: for the purposes of this test, 1MB = 1,048,576 bytes.)
In the remaining segments, a random starting sector is chosen that is at most 4MB from the end of the segment.

Next, nine blocks of random data, each 4MB in length, are generated and held in memory. (This number was chosen in the hopes that it would exceed the foreseeable write cache size of any SD card by at least a factor of 2.) Each block is written to the card, in a linear fashion, starting with each of the starting sectors chosen earlier. The final 4MB is written in a linear fashion starting 4MB from the end of the device’s logical address space. (Edit 3/13/2024: At some point I made a change so that the blocks are written in reverse order — e.g., starting with the last block and working back to the first. Within each block, however, data is still written sequentially from beginning to end.) Each block is then read back and compared to the data written. If all nine blocks match what was written to the card, the card is considered “genuine”; e.g., that its physical space matches (or possibly exceeds) the amount of space indicated in its CSD register. If the contents of the first block do not match what was written to the card, the card is considered unusable and testing stops completely. Otherwise, the card is considered “fake”. The logical space on the card is then bisected, 4MB of new random data is generated and written starting at the sector in the center of the new window, then read back and compared to the data written. This process is repeated until the extent of the card’s physical space has been determined.

I should note that my algorithm isn’t perfect — I’ve come across some fake flash that purported to be 512GB (but in actuality was closer to 32GB) that was misidentified as being closer to 256GB in size. In these situations, I’ve been allowing the first round of the endurance test to run on the device and using the results of that to determine where the card’s physical space ends.

Performance

The performance test is divided into two parts: a sequential I/O test and a random I/O test. Each of these parts is divided into a read test and a write test. The read test is performed first, followed by the write test. Data obtained from read operations is not checked for consistency. USB3-enabled readers are used to ensure that the speed of the USB bus is not a bottleneck.

During the sequential I/O tests, data is read from or written to the device continuously for 30 seconds. Data is read from or written to the device in chunks equal to the logical sector size (512 bytes) multiplied by the maximum number of sectors per request (as indicated by a BLKSECTGET ioctl call). After 30 seconds have passed, the total amount of data read or written is divided by the amount of time actually taken (measured with microsecond resolution) to determine the sequential data rate measurement.

During the random I/O tests, data is read from or written to the device continuously for 30 seconds. Each read or write operations is targeted to a random sector in the card’s physical storage space (as determined during the authenticity test). Data is read from or written to the device in 4KB chunks (as prescribed by section 4.16.2.4.2 of the SD Card Physical Layer Simplified Specification, version 9.0). After 30 seconds have passed, the total number of I/O operations is divided by the amount of time actually taken (measured with microsecond resolution) to determine the random IOPS measurement.

Again, these tests aren’t perfect. In fact, there’s a number of issues with them. For example:

Most speed classes require you to issue a CMD20 command to the card to put it into an operating state where it will meet the demands of that speed class. Most USB card readers (including the ones I’m using) don’t provide a way to issue arbitrary commands to a card. The reader might be issuing this command to the card transparently to my application, or it might not be — I just don’t know.
SD cards are divided into sections, called Application Units (or AUs). The Video Speed Classes in particular require certain commands to be issued to it to put the card into Video Speed Class mode and to specify which AU the host will be writing to. The host is then supposed to write only to that AU, in a sequential fashion (skipping over any blocks that are already in use). Once the host has reached the AU, it must issue another command to specify which AU it will be writing to next. Again, my card readers don’t provide a way for the host to issue these commands to the card, so my application isn’t doing this. Given the complexity involved in using Video Speed Class mode, I doubt that any of the card readers I’m using are doing this transparently for me.
The Application Performance Classes require the card to be preconditioned in a certain way — e.g., you’re supposed to start by fully erasing the card, filling up 75% of it with data, then overwriting part of that data with 256MB of data (written in a sequential fashion). You’re then supposed to use that 256MB region for performing the actual performance tests. The test itself is supposed to last for 10 minutes. My application does not do this — primarily because, when I initially wrote the random I/O tests, I got my technical details from Wikipedia, which fails to mention any of these details. Additionally, the host is supposed to issue a number of commands to the card to perform the preconditioning — for example, CMD38 is to be used to perform a full erase of the card; CMD25 is to be used when filling up 75% of the card; and, if Application Performance Class 2 is being tested, CMD45/CMD46/CMD47/CMD48 are to be used to perform the actual reading/writing. Again, my card readers don’t provide a way to issue these commands to the card, so I have no way of doing this.
In addition, read and write operations for the Application Performance Class tests are supposed to be 4KB-aligned. I didn’t fix this in my code until just now.

So I think I’m going to say that my tests encompass the spirit of each of the speed classes…but until I learn Verilog and can program an FPGA to perform a proper set of speed tests, my tests aren’t going to truly accurate.

Endurance

The physical space on the card’s user area (as determined during the authenticity test) is divided into 16 roughly equal segments — that is, the physical number of sectors is divided by 16 (rounding down), and each segment is assigned that number of sectors. The first segment begins at sector (physical_number_of_sectors / 16) * 0, the second segment begins at (physical_number_of_sectors / 16) * 1, the third segment begins at (physical_number_of_sectors / 16) * 2, and so on. If the number of physical sectors on the card is not evenly divisible by 16, any extra sectors are assigned to the last segment. (I’ll note that while it’s possible for an SDSC card — that is, a card that is 2GB or less in size — to have a number of sectors that is not evenly divisible by 16, it’s not possible for an SDHC, SDXC, or SDUC card. This is because, for an SDHC, SDXC, or SDUC card, the card’s capacity [in bytes] is determined by taking the contents of the C_SIZE field — from the card’s CSD register — and multiplying it by 512KB (or 524,288), which is itself a multiple of 16 sectors [or 8,192 bytes]. However, in practice, the authenticity test frequently finds fake flash whose physical number of sectors is not a multiple of 16.)

At the beginning of each round, the order of the segments is randomized. Then, for each segment (in the order they appear in the randomized list), a seed is determined, and a pseudorandom number generator is initialized with that seed. Pseudorandom data is then generated and written to the entire segment in a sequential fashion.

Once all segments have been written, the order of the segments is randomized again. Then, for each segment (in the order they appear in the randomized list), the pseudorandom number generator is re-initialized using the same seed that was used when the data was written to that segment. The pseudorandom data is regenerated; the data is read back from the card (again, in a sequential fashion) and compared to the pseudorandom data. If any discrepancies are found, the sector in which discrepancy appeared is flagged as “bad”. (The program continues to write to/read from sectors that have been flagged as “bad”, but does not take any further action if further discrepancies are found in those sectors.)

One all segments have been read back, the round is considered complete, and the program moves on to the next round.

If an I/O error occurs, the program has logic to detect whether the device has become disconnected from the system. If it has, it pauses, displays a message to the user, and waits for the device to be reconnected. If the disconnect occurred during a write operation, the segment in which the error occurred is restarted to avoid any corruption that may have occurred due to the contents of any write caches being lost at the time of the disconnect.

If it is determined that the device is still connected to the system, the program has logic to retry the I/O operation a set number of times. If all of those attempts fail, the program attempts to perform a reset operation on the card reader. Once the reset is complete, the program makes another set of attempts to retry the I/O operation. This process is repeated a set number of times, or until the I/O operation completes successfully. If all retry/reset attempts are exhausted, the program flags the sector in which the error occurred as “bad” and moves on to the next sector. (I’ll note that, at present, there is no distinction between a sector that has been flagged as “bad” due to a data discrepancy and a sector that has been flagged as “bad” due to a failed I/O operation; therefore, the program will still attempt to read and write to the sector on future rounds.)

This process repeats until any of the following conditions are met:

An I/O error occurs, a reset operation is performed, and the reset attempt failed
50% or more of the sectors on the card have been flagged as “bad”

In the former case, there have been some instances where I’ve been able to “resurrect” the card and continue testing — generally by physically unplugging the card reader from the system and plugging it back in. If the card comes back to life through such a measure, I’ve generally allowed the endurance test to continue.

Card Readers Used

I’ve used the following card readers in my testing so far:

SmartQ Single: A nice low-cost SD card reader that supports USB 3.0. However, in my testing, this reader has a tendency to stop responding after extended continuous use (generally once every few days). The reader has to be physically unplugged and reconnected to continue working.
SmartQ Duo: Slightly more expensive than the SmartQ Single and sporting an almost identical form factor, it supports dual LUNs (meaning that it can operate on two cards simultaneously — one in the microSD slot, one in the full-size SD slot). It doesn’t seem to have the same problems with disconnects that the SmartQ Single does.
SanDisk MobileMate: A compact reader that only accepts microSD cards. SanDisk has a technology that allows for faster transfer rates than is possible under the UHS-I protocol (up to 170MB/sec), and requires both a compatible card and a compatible reader to achieve. This reader supports these enhanced transfer rates.
JJS CR-UTC4AC: A slightly larger, but still compact, SD/microSD card reader. This is a dual-LUN reader that supports UHS-II, and features USB-C, USB-A, and micro-USB connectors (although the micro-USB connector only supports USB 2.0). This has quickly become my reader of choice as it is only slightly more expensive than the SanDisk MobileMate while supporting UHS-II. I’ll note that some of these readers were sourced from Amazon Marketplace, while others were sourced from AliExpress; however, they are physically identical (at least on the exterior), and the product packaging was identical. I believe that there are no differences between the two.
Lexar LRWM05U-7000: This is a compact UHS-II-compatible microSD reader that was bundled with the two Lexar Professional cards I purchased. It looks like Lexar doesn’t sell these by themselves.
Prograde Digital Dual Slot Mobile Reader: A compact SD/microSD card reader with dual slots and dual LUNs that sports a USB-C connector and supports USB 3.2 and UHS-II. At some point I made the decision that I wanted to have at least one UHS-II-compatible card, and went in search of a good quality UHS-II-compatible card reader. This one initially appeared to be the best/cheapest option (until I later discovered the JJS CR-UTC4AC). I haven’t noticed any significant difference in performance between this one and any of the other readers I’m using. Its main downside is its USB-C connector — only because I only have a single USB-C port across the two machines that I’m presently using.
Platinum PT-CRSA1: A more moderately-priced single LUN SD/microSD card reader. Honestly, I bought this one because I ran out of SD readers, and I happened to be at Best Buy at the time, and I wanted to see if they had anything comparable to what I had been using. This happened to be the cheapest USB 3.0-compatible card reader they had. I would say it’s been fine, but I won’t be buying any more of these — partly because the JJS CR-UTC4AC is a better value for slightly less money, but partly because Best Buy doesn’t carry them anymore.
Togconn TOG-SD-CR: A nice low-cost multi-LUN card reader. This reader can read two SD cards, a Memory Stick, a CompactFlash card, and an xD card simultaneously. (This reader has two full-size SD card slots and two microSD card slots, but each full-size SD/microSD slot pair are a single LUN.) At one point, I was looking to see if there was a cost-effective way to test multiple cards at the same time. While there are readers out there that will read four SD cards simultaneously, they cost more than what I wanted to pay — so I settled on this one instead. Originally the plan was to use a microSD-to-Memory Stick adapter, a microSD-to-CompactFlash adapter, and a microSD-to-xD adapter to fill all of the available slots on this card reader; however, my results have been disappointing. While the microSD-to-CompactFlash reader is working well, I quickly noticed that a microSD card plugged into a microSD-to-Memory Stick adapter appeared to the reader as the wrong size. Reviews of microSD-to-xD adapters indicated poor results as well, so I opted not to even try. Consequently, I currently have two microSD cards plugged directly into this reader, with a third card plugged in using a QUMOX B664U microSD-to-CompactFlash adapter. (I’m not using the second port on the QUMOX, as that would cause it to RAID the two cards together — which I don’t want.)
Realtek RTS5129: This card reader isn’t one I purchased directly; rather, it was built into one of the laptops that I used as one of my test rigs. Its primary advantage is that the Linux kernel module presents it as an SD/MMC reader (rather than a generic block storage device, as with all the other readers I’ve used). Since it’s wired up to the USB 2.0 bus internally, I didn’t use it for any performance testing; I only used it to read the contents of the various card registers for later analysis.

Overall Scoring

As I was working on writing this, I realized that I needed a rating system for these cards. I was originally just looking at the top 10 in each of the three categories, but it became apparent that there were no crossovers between the top 10 in all three categories. There were a few that appeared in the top 10 in both the capacity and endurance categories — but it was only four of them, and two were from brands that were known to put out fake flash. That wasn’t ideal — so I decided to come up with a different system.

Here’s how it’s going to work:

Each model will receive a separate score in each of the three categories (capacity, performance, and endurance). The total score for that model will be the average of the three scores.
The score for the capacity test will be the distance, in standard deviations, of that model’s average skimp score from the average skimp score for all cards. Since we want to penalize fake flash and (to a lesser extent) skimpy flash, we’re going to negate the score — ergo, fake flash will generally have a negative score here, and genuine flash will generally have a positive score.

Let’s look at an example. Let’s say a card has a skimp score of 3.3%, the average is 14.29%, and the standard deviation is 31.33%. This would mean that the card’s skimp score is actually 0.35 standard deviations below average ((3.3 - 14.29) / 31.33 = -0.35). We then negate this result, which would give us a score of +0.35.

This is going to penalize fake flash — and hard — and that’s kinda the idea. We don’t want to reward fake flash at all.
The score for the performance test will consist of four sub-scores, for each of the performance metrics (sequential read speed, sequential write speed, random read speed, random write speed), averaged together. As with the capacity test, we’ll use the distance, in standard deviations, from the average. Here, we want to reward faster-performing cards, so we’re not going to negate the scores like we did with the capacity score — the best-performing cards will generally have a positive score, while the worst-performing cards will generally have a negative score.

Let’s look at an example. Let’s say a card got 100MB/sec sequential read speeds, 50MB/sec sequential write speeds, 2,000 IOPS/sec random read speeds, and 250 IOPS/sec random write speeds. Now, let’s say the averages are 50MB/sec sequential read speeds, 25MB/sec sequential write speeds, 1,000 IOPS/sec random read speeds, and 350 IOPS/sec random write speeds. Finally, let’s say the standard deviations are 25MB/sec in sequential read speeds, 25MB/sec in sequential write speeds, 100 IOPS/sec random read speeds, and 50 IOPS/sec random write speeds. That would mean that the card scored 2 standard deviations above average in sequential read speeds ((100 - 50) / 25 = 2), 0 standard deviations above average in sequential write speeds ((50 - 50) / 25 = 0), 10 standard deviations above average in random read speeds ((2000 - 1000) / 100 = 10), and 2 standard deviations below average in random write speeds ((250 - 35) / 50 = -2). The individual scores for this card would be 2, 0, 10, and -2. We then take the four scores and average them together, giving it an overall performance score of 2.5 ( ( 2 + 0 + 10 + -2 ) / 4 = 2.5).
The score for the endurance test will consists of six sub-scores: one for the number of read/write cycles the card endured before experiencing its first error, and one each for how many read/write cycles the card endured before 0.1%, 1%, 10%, 25%, and 50% of the sectors on the card have been marked as “bad”. If a card fails before reaching any of these thresholds, they will be considered to have instantly hit those thresholds. We want to reward cards that fail more slowly, so we’re going to take each threshold and subtract it from the previous one to figure out how many read/write cycles it went between hitting each one. For example, if a card hits the 1% threshold after 2,500 read/write cycles, and it hits the 10% threshold after 3,500 read/write cycles, then we’ll use the difference between the two — 1,000 in this example — as the basis for calculating the score. We’ll then figure out the distance, in standard deviations, from the average for each category, and finally we’ll average all six scores together.

Ok, that was a mouthful, so let’s look at an example. Let’s say a card experiences its first error at 1,000 read/write cycles, it hits the 0.1% threshold after 2,000 read/write cycles, the 1% threshold after 3,000 read/write cycles, the 10% threshold after 4,000 read/write cycles, the 25% threshold after 5,000 read/write cycles, and the 50% threshold after 6,000 read/write cycles. That means that we would use 1,000 as the basis for calculating each score.

Now, let’s say that the average for each category is 500, and the standard deviation is 250. A score of 1,000 would be two standard deviations above the average ((1000 - 500) / 250 = 2), so the card would receive a score of 2 in each of the six categories. We then take the average of all six scores — which would be 2, so the card would receive a score of 2 for endurance.

This isn’t a perfect system — obviously, a card’s score is going to change whenever I test any other card — but it does give us something that lets us easily and objectively rate one card in comparison to the others. A perfectly average card will have a score of 0; a below average card will have a negative score; and an above average card will have a positive score.

Results

There’s a number of ways I could break down this data. Since I did define some goals for this project, let’s go in order of those goals.

Capacity

As I said earlier, I wanted to identify whether these cards really offered the capacity that they advertised. For this result, I created a metric called “skimp” — which I’m defining as:

S = 1 – (C_Physical/C_Package)

Where C_Physical is the card’s physical capacity, C_Package is the capacity advertised on the package (or in some cases, on the exterior of the card or on the product listing for the card), and S is the skimp factor, expressed as a percentage. Think of it like the answer to the question of “how much capacity am I actually getting vs. how much I paid for?” Lower numbers (or even negative numbers) are better. For example, if a card is advertised as being 8GB in size, and the physical storage capacity is 7.8GB, then it would have a skimp factor of 2.5%, because you lost 2.5% of the stated capacity of the card. On the other hand, if a card is advertised as being 8GB in size, and it turns out to actually be 8.2GB in size, then it would have a skimp factor of -2.5%. I used linear scaling for data storage prefixes (e.g., one kilobyte = 1,000 bytes, one megabyte = 1,000 kilobytes, etc.), because if I had used binary scaling, no card would have had a skimp level anywhere close to 0.

So…is there a difference between the cards I got from Amazon vs. the cards I got from AliExpress?

(Error bars represent the range of values obtained.)

At first glance, it would look like the AliExpress cards were a lot more skimpy — and they were — but there’s a reason for this: I only ordered authentic cards from Amazon, whereas I ordered a mix of authentic and fake cards from AliExpress.

What if we narrow down the data to just the authentic cards from both marketplaces?

Well, the margin is a little closer here, but the AliExpress cards were still skimpier. Why is that? Let’s break this down further: both by which marketplace I obtained them from, and by brand/model. (Note that I’m adding the off-brand/knockoffs back in — just so that I don’t have to make another chart later that has all the cards.)

(Side note: I like making rainbows.)

Admittedly it’s kinda hard to tell with this chart — because it includes the fake cards, and the chart has to scale to show those — but aside from the Kingston Canvas Select Plus’s, all of the Amazon cards had a skimp factor of 0.65% or less, whereas the AliExpress cards — even the name-brand ones — were all over the place (with the Kioxia Exceria Plus 32GB being the worst non-fake flash offender, coming in at a skimp factor of 3.32%).

From this data, I think we can draw a couple of conclusions:

Authentic cards generally have a skimp factor of 5% or less.
Fake cards generally have a skimp factor of 50% or more.

Is it possible for a card to be fake and have a skimp factor of less than 50%? Sure — but in practicality, it doesn’t seem to happen. I think it’s more practical for fake flash sellers to scale up the logical storage space by a factor of 2 or more. (Edit: OK, the QWQ Extreme Pro proved me wrong here.)

By that same token, is it possible for an authentic card to have a skimp factor of more than 5%? Sure — I just didn’t find any examples of this happening.

We can also pick out the top 10 performers in this category:

Auotkn Extreme 8GB
QEEDNS 8GB
Bekit 8GB
Lexar Professional 1000x 64GB
Samsung PRO Endurance 32GB
Samsung EVO Plus 64GB
Samsung EVO Plus 32GB
Hiksemi NEO 8GB
Amzwn 32GB
SanDisk Extreme 64GB

(Note: The charts above are being automatically rendered using data from my spreadsheet — so it’s possible that the charts above indicate a different top 10, and I just haven’t updated the list above. The list here is current as of 3/18/2024.)

Here’s how these cards lined up on my rating scale:

We can also look at these cards from another angle: price per gigabyte:

Here, we can see that the AliExpress cards had a little bit of an advantage. Here’s how it shook out for all of the cards I’ve tested so far:

Here, the Hiksemi NEO 128GB is the clear winner — and honestly (for reasons I’ll discuss later on), this card is a good buy.

Last updated: 3/18/2024

Performance

The second goal of this project was to look at performance — so let’s compare how the Amazon cards performed when compared to the AliExpress cards.

(Error bars represent the range of values obtained.)

At first glance, it would appear that there’s a marked difference between the Amazon cards and the AliExpress cards — with Amazon cards performing better than the AliExpress cards across the board and with less variability in scores across Amazon cards vs. AliExpress cards. Again, however, I primarily obtained name-brand cards from Amazon, whereas I got a mix of name-brand, off-brand, and knock-off cards from AliExpress. What if we separate the AliExpress cards out into name-brand cards, off-brand cards (fake and authentic), and knockoff cards (fake and authentic)?

Now it looks like the name-brand cards I got from AliExpress did on par with — or even better than — the Amazon cards.

But it also highlights a couple more important differences:

Categorically, off-brand cards did worse than name-brand cards in all performance metrics.
Categorically, knockoff cards did worse than off-brand cards, and much worse than name-brand cards, in all performance metrics. (Yes, all of the fake cards I tested got less than 10 write operations per second on the random write test. Yes, some of them got less than one write operation per second. I don’t know how they managed to suck so bad…but they found a way.)

Ok, let’s spin this a different way: which brands/models performed the best? First, let’s look at the individual scores in each category:

Now, how did these cards score according to my ratings system?

The graphs in this section are all dynamically generated from my data — so the top 10 may change at any point. But as of this writing, the top 10 would be:

SanDisk Extreme 64GB
Kioxia Exceria G2 64GB
Samsung EVO Plus 64GB
SanDisk Extreme 32GB
Kingston Canvas Select Plus 32GB
Samsung PRO Endurance 32GB
Lexar Blue 633x 32GB
SanDisk Extreme PRO 32GB
Hiksemi NEO 8GB
SanDisk Ultra 32GB

We can also look at this a different way: which cards would work best in certain applications?

When using a microSD card in a digital camera, sequential write speeds are generally going to be the most important. When taking still photographs, the camera must generally be able to write the picture out to the card before it can take the next one — so faster write speeds means the camera can be ready to take the next picture sooner. When shooting video, the camera has to be able to write data out to the card faster than the camera can generate it — if it can’t, it generally has to stop recording video. Sequential read speeds are important as well, as you generally want to be able to offload pictures and videos — to, say, your computer — very quickly.

The nice thing about this ratings system is that I can very easily re-weight certain categories. So for this rating, let’s give the sequential write speed double weight, and random I/O scores half weight:

So, for photography/videography, my top picks here would be:

SanDisk Extreme 64GB
Kioxia Exceria G2 64GB
SanDisk Extreme 32GB
SanDisk Extreme PRO 64GB
SanDisk Extreme PRO 32GB
Hiksemi NEO 128GB
Hiksemi NEO 8GB
Kingston Canvas Select Plus 32GB
Samsung EVO Plus 64GB
Kioxia Exceria Plus 32GB

The other way we could look at it is in something like a tablet, mobile phone, or mobile game console (like a Nintendo Switch or a Steam Deck). Here, random read speeds are going to be most important — as you want your apps/games to load quickly. Sequential write speeds are going to be a factor as well — as that’s going to affect how quickly you can download new apps and games.

So let’s re-weight these cards — we’ll give random read speeds double weight, and we’ll give random write and sequential read speeds half weight:

So, the top picks here would be:

SanDisk Extreme 64GB
Kioxia Exceria G2 64GB
SanDisk Ultra 32GB
Samsung PRO Endurance 32GB
Samsung EVO Plus 64GB
SanDisk Extreme 32GB
Kingston Canvas Select Plus 32GB
Lexar Blue 633x 32GB
SanDisk Extreme PRO 32GB
SanDisk Extreme PRO 64GB

(Note: I’ve removed the Lexar Professional 1000x 64GB from all of the top 10’s. After the issues that I experienced with them, I just can’t recommend that anyone buy them. See the discussion on that card for more details.)

Last updated: 3/18/2024

Endurance

This is the area where I’m most unready to publish results, but I’m going to publish what I have. Why is that? Well…endurance testing takes a while. A long while. On average, these cards can complete about 35 read/write cycles per day, but that number is pretty variable depending on the size of the card, how well it performs, how many errors it runs into, and how many other cards I have running on the same system. Some of them have been able to complete over 200 read/write cycles per day — meaning that it can hit 2,000 read/write cycles in as little as 10 days. Others are only been able to complete about 3.6 read/write cycles per day — meaning that it’s going to take a year and a half to get to 2,000 read/write cycles. I’ve only been running this project for 6 months now — so I’ve got a long way to go.

Some of these cards have been going through endurance testing for eight months now, and have yet to experience a single error. I bought an initial batch of 21 cards; out of those:

Eleven are still going through their endurance tests.
Five haven’t even experienced a single error yet.

I have 178 cards right now (plus another 10 on order — and that’s assuming I don’t order more, which is a definite possibility). Out of those:

I’ve only managed to destroy 32 of them.
87 of them are still going through endurance testing.
The remaining 59 haven’t undergone any testing yet.

So…when I say these results are preliminary and subject to change, keep in mind that they are very preliminary and very subject to change.

Since I’ve started the previous two sections by comparing Amazon cards to AliExpress cards, let’s start with that. Keep in mind, many of these cards that are represented in this data are still undergoing endurance testing — so the data represents how many rounds the cards have endured so far, as opposed to how many they will ultimately endure. Also, I started different cards at different times — so the data is going to be skewed a little bit because of that.

I’m not going to try to justify the difference between the Amazon and the AliExpress cards, because there’s several factors affecting how many read/write cycles I’ve been able to complete:

Most cards are still undergoing endurance testing.
I’m testing cards of various sizes, and it takes longer to test a bigger card than a smaller card. For example, all other factors being equal, it’s going to take 16 times longer to complete a single round of testing on a 128GB card than on a 4GB card. (Don’t get me wrong — I’ve been tempted to buy the SanDisk Ultra 1.5TB or the Kioxia Exceria Plus 2TB card that Kioxia just announced, but they’re a little cost prohibitive right now. If anyone from SanDisk or Kioxia is reading this and you’re willing to send me some samples of these cards, I’ll happily add them to these results.)
I started testing these cards at different times. I started this project in August of 2023. The most recent set of cards started testing in May 2024. I’ve been starting new cards at the rate of about 2-3 per week.
I’m saturating the USB bus on both machines that I’m using for testing. Almost all of my cards are not running at their full speed potential during the endurance test because the bandwidth simply isn’t available. For endurance testing, I didn’t consider this to be an important factor, because the endurance test isn’t about speed. (Side note: I’ve coded my program so that if I’m running a performance test, all other instances of my program pause what they’re doing so that they’re not sucking up USB bandwidth and negatively affecting the results.)

I have started keeping track of how long cards go between their initial failure, the 0.1% threshold, the 1% threshold, the 10% threshold, the 25% threshold, and the 50% threshold. I don’t want to call out individual brands/models here — because I only have 32 cards total that have failed thus far. However, for the cards that have completely failed, here’s how things shook out:

Measure	Average	Standard Deviation	Max
Number of read/write cycles completed before first error	1,566	1,694	6,111
Number of read/write cycles completed between first error and 0.1% error threshold	838	1,511	5,914
Number of read/write cycles completed between 0.1% and 1% error thresholds	257	1,018	5,791
Number of read/write cycles completed between 1% and 10% error thresholds	68	155	701
Number of read/write cycles completed between 10% and 25% error thresholds	43	136	745
Number of read/write cycles completed between 25% and 50% error thresholds	46	114	531

But with only 32 samples, it doesn’t seem like we have very high quality data — especially when we know that we have cards that will skew these results when they finally start experiencing errors. For example, sample #1 of the Hiksemi NEO 8GB is currently at over 49,000 read/write cycles; if it were to die right now, the average number of read/write cycles completed before first error would double, and the standard deviation would jump by a factor of nearly 5. So clearly we need to wait for some of these more reliable cards to die to get better results.

In order for us to make sense of these results, I think we have to take a more qualitative look at the data rather than a quantitative look.

Earlier on, I said that I was going to use 2,000 read/write cycles as the threshold for a card to be considered “reliable”. It’s an arbitrary number, but it was based on some other reading I had been doing. So, I think we can spin this in two ways:

Which models have made it successfully past the 2,000 read/write cycle mark without errors?
Which models experienced errors before hitting the 2,000 read/write cycle mark?

In the first category, we have the following:

Brand/Model/Capacity	Samples (total that survived 2,000 read/write cycles without errors/total samples tested so far)
Auotkn Extreme 8GB	3/3
Bekit 8GB	1/3
Chuxia 32GB	1/3
Cloudisk 32GB	1/3
Hiksemi NEO 8GB	2/3
Hiksemi NEO 32GB	1/3
Hiksemi NEO 128GB	1/3
Kingston Canvas Select Plus 32GB	3/6
Kioxia Exceria 32GB	1/1
Kioxia Exceria G2 64GB	2/3
Kioxia Exceria Plus 32GB	2/3
Kodak Ultra Performance 32GB	1/1
Kodak Ultra Performance 64GB	1/3
Lexar Blue 633x 32GB	1/3
“Lenovo” 2TB	1/1
Microdrive “Bart Simpson” 16GB	3/3
Netac PRO 16GB	1/1
OV 32GB	2/3
QEEDNS 8GB	1/1
Samsung EVO Plus 32GB	1/2
Samsung PRO Endurance 32GB	1/1
SanDisk Extreme 32GB	1/3
SanDisk Extreme 64GB	1/2
SanDisk Extreme PRO 32GB	1/3
SanDisk Extreme PRO 64GB	2/2
SanDisk High Endurance 64GB	1/3
SanDisk Industrial 8GB	3/3

For the second category…well, let’s just say this: of the cards where I have at least three samples in testing or that have completed testing, there’s only three cards where all samples made it past the 2,000 read/write mark: the Auotkn Extreme 8GB, the Microdrive “Bart Simpson” 16GB, and the SanDisk Industrial 8GB. All of the others had at least one card that experienced errors before hitting the 2,000 read/write cycle mark.

To get a list of top performers, let’s narrow down the list above to just the ones where all samples survived for at least 2,000 read/write cycles without errors. The current contenders — as of this writing — are (in order from “most read/write cycles survived without errors” to “least read/write cycles survived without errors”):

Frankly, I don’t like this list, for a couple of reasons:

Three of these are on the list based on the results from one sample. As of the time of this writing, I have other samples to test — they just haven’t been tested yet.
One of these options (the “Lenovo” 2TB) is fake flash. This card should have no business being this reliable.

Last updated: 5/11/2024

Known Failure Modes

There were a number of ways in which I observed cards failing. I’m lumping them into two categories: data verification errors, and card failures. The “data verification errors” category consists of bit flip errors, data shift errors, missing data errors, and corrupted data errors. The “card failures” category consists of unresponsive cards, corrupted CSDs, and write-protected cards.

Bit Flip Errors

The term “bit flip errors” refers to a phenomenon when the data read back matches the data written to the card, with the exception of a few bits — or sometimes only one bit. Bit flip errors can occur when a bit flips from a 0 to a 1, or from a 1 to a 0. Bit flip errors tended to happen most frequently on fake flash and low-quality flash, and once they started, they tended to increase in number and frequency.

Data Shift Errors

I’m using the term “data shift error” to refer to a phenomenon where data that is expected to show up in one sector appears two sectors later. (When I say “data”, I’m referring to all 512 bytes in a sector — not just a portion of it.) This phenomenon affects a variable number of sectors at a time; however, most times the number of sectors is in the single-digits.

It took me some time to notice this phenomenon occurring; however, once I did, I started noticing it happening more and more. It doesn’t seem to be isolated to any particular brand of card or any particular card reader. It’s frankly baffling the hell out of me, because I don’t know if it’s just something wrong with the cards or if it’s something else. However, this tended to be a pretty common failure mode for name-brand cards.

Missing Data Errors

I’m using the term “missing data error” to refer to a situation where a card responded to a read request, but the data returned consists of a single byte repeated over and over (usually 00 or ff). This type of error tends to occur with fake flash when reading from a sector that isn’t mapped to a physical sector in the card’s flash storage.

Corrupted Data Errors

I’m using the term “corrupted data errors” to refer to any other situation where a card responded to a read request, but the data returned did not match the data written. Sometimes this can be due to a write request that was cached by the card but not written out (or only partially written out) to the card’s flash storage. In general, though, I’m using this term to refer to a data verification error that doesn’t fit into any of the other categories.

Unresponsive Cards

I’m using the term “unresponsive card” to refer to a situation where the system did not expose the card as a block device when plugged into a card reader.

Upon further inspection, I managed to get a little more insight as to what’s happening with at least some of these cards. When initializing a card, the host is supposed to send ACMD41 to the card to tell it to begin its power-up sequence. While the power-up sequence is taking place, the host can issue additional ACMD41s to the card to ask the card whether it has finished powering up. From the time the card gets the first ACMD41, it has one second to complete its power-up sequence. With at least a few cards, I could see it responding to the ACMD41s commands, but they would never indicate that their power-up sequence was complete.

I was able to unintentionally trigger this scenario with a working card while working on an FPGA design — and after diagnosing the issue for some time, I concluded that the issue was that the card was being undervolted. This leads me to conclude that the “dead” cards have some component (like a resistor, transistor, diode, etc.) that has failed, and is either preventing the card from getting up to operating voltage or is preventing it from detecting that it got up to operating voltage.

Corrupted CSD

The CSD register is a register that the host can read from the card, and specifies a number of parameters for the card — such as whether the card is write protected, how much time it should take for a nominal write operation to complete, and — most importantly — the size of the card. There have been two instances (with a single brand of card) where the contents of the card’s CSD register changed, which resulted in the overall capacity of the card changing to be far less than what it was originally. When this has happened, I’ve immediately declared the card “dead” without any further testing.

Write-Protected Cards

Some cards have been known to make themselves write-protected — either by indicating as such in the CSD register or by exhibiting I/O errors whenever writes are attempted. It is not known whether this behavior is accidental or by design. If this behavior is by design, a hypothetical design might be as follows:

A card has a certain number of “spare” sectors. These sectors are designated for performing wear leveling and/or bad sector replacement.
The card maintains a sector map, for its internal use, that maps logical sectors to physical ones. When the host requests a given sector, it uses this map to determine the physical location of the requested sector in the flash core.
As wear leveling is performed, the sector map is updated to reflect the physical location of each logical sector in the card’s user area.
If a bad sector is detected, it is flagged as such in the sector map and replaced with one of the spare sectors — thus reducing the number of spare sectors available.
Once the card runs out of spare sectors (or falls below a defined threshold), it makes itself read-only to protect the integrity of the data already on the card.

Of course, the other explanation is that this behavior is accidental — for example, the portion of flash memory where the card stores its write-protect flags could become corrupted, causing it to report that it is write protected.

Regardless of the mechanism, when this situation occurs, I’ve generally tried to reset the card — by pulling it from the reader and reinserting it — to try to resolve the situation. (After all, there is a “write protect until power cycle” flag in the Physical Layer Specification.) If that fails to fix it, I’ve declared the card “dead”.

Overall Picks

To get a list of top performers, I’m going to look at the top scores in the capacity and performance categories. For now, I’m not going to include any of the endurance data in here, as I still have incomplete data for all but a handful of cards.

Note: This list is subject to change at any time!

Here’s how the actual scores shook out:

This lines up pretty well with the results that I’ve been seeing — so maybe my rating system isn’t so bad after all.

Last updated: 4/17/2024

Individual Cards

Below are the results that I've gotten from each brand/model of card -- in alphabetical order by brand/model/capacity -- along with a discussion indicating why I chose this card, things that I found out about the cards, things that happened during testing, etc. A few things to note as you peruse this list:

Prices paid are shown in US Dollars.
Prices paid include shipping to the United States. In instances where I ordered multiple items from the same seller, I've divided the shipping amount by the number of items I purchased to determine a per-item shipping price.
Priced paid do not include sales tax -- as sales tax in the US varies widely depending on where you live.
The data is organized by brand name. If all of the cards underneath that brand name have the same value for one of their attributes, I'll list it in the bulleted list. Otherwise, I'll list it in the table. (For example, if I obtained three of a particular brand, and I paid the same price for all three of them, I'll list it in the bulleted list. If I paid different prices for any of them, I'll show the prices in the table instead.
"Card reader used" indicates the card reader that was used for doing performance testing. In some cases, I've moved the card over to another card reader afterwards.
I'm not done testing everything! I'll update this page as I get more results.

Amzwn 32GB

Obtained from: AliExpress
Price paid: $4.92
Advertised capacity: 32GB
Logical capacity: 31,954,305,024 bytes
Physical capacity: 31,954,305,024 bytes
Fake/skimpy flash: Skimpy (0.14% skimp)
Protected area: 83,886,080 bytes
Adjusted skimp: -0.12%
Speed class markings: Class 10, U3, A2
CID data:
- Manufacturer ID: 0x9f
- OEM ID: 0x5449 (ASCII: TI)
- Product name: 0x3030303030 (ASCII: 00000)
- Product revision: 0x00

Sample #	1	2	3	Average
Serial number	`0x00000026`	`0x0000001e`	`0x00000011`	N/A
Manufacture date	Feb 2023	Feb 2023	Feb 2023	N/A
Sequential read speed (MB/sec)	22.72	22.43	22.74	22.63
Sequential write speed (MB/sec)	12.40	11.48	12.18	12.02
Random read speed (IOPS/sec)	1,060.51	1,149.89	971.34	1060.58
Random read speed (IOPS/sec)	149.89	166.74	150.42	155.68
Read/write cycles to first error	1,535	1,987	41	1,188
Read/write cycles to complete failure	Not yet determined	1,990	1,721	1,856
Total days to complete failure	Not yet determined	110	113	112
Card reader used	JJS CR-UTC4AC	SmartQ Single	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

Amzwn is a brand that appeared pretty frequently while I was browsing AliExpress -- both when searching for microSD cards, and as recommendations on other products. They appear to come in various sizes, ranging from 32GB to 256GB. At least one version of their card is labeled as "Amzwn basics", with an arrow similar to the "A to Z" arrow used in Amazon's logo appearing underneath Amzwn. Combined with the similarity to Amazon's name, this strongly suggests that they are hoping buyers will confuse them with Amazon.

Overall, I wasn't terribly impressed with these cards. Read/write speeds were well below average, and not high enough to warrant any of the speed class marks that it bears, with the exception of the Class 10 mark.

Sample #1's first error was a data verification failure affecting two sectors during round 1,536. It has survived 1,556 read/write cycles in total so far.

Sample #2 almost made it to the 2,000 read/write cycle mark without errors -- but then it started failing, and hard. Its first error was a series of bit flip errors during round 1,988; by the end of round 1,989, those errors had affected over 1% of the total sectors on the device, and by the end of round 1,990, it had affected every sector. Here's what the progression looked like:

Sample #3 experienced its first error early on, but that error was pretty minor -- only affecting four sectors. It continued to experience sporadic errors over the next several hundred rounds, but again, those errors were relatively small -- only affecting 56 sectors total over 1,720 read/write cycles. During round 1,721, however, it started experiencing a large number of bit flip errors. During round 1,722, those errors must have begun to affect the storage area that the card uses for the CSD data -- because it suddenly began reporting itself as being 2TB in size. At that point I decided to declare the card dead. Here's what this card's progression looked like:

Overall, these cards were poor performers. On the bright side, they're not fake flash; and while they were skimpy, they were definitely not the worst offenders. But would I buy them? Nah -- there are WAY better options out there.

Last updated: 4/27/2024

Auotkn Extreme 8GB

Obtained from: AliExpress
Price paid: $2.58
Advertised capacity: 8GB
Logical capacity: 8,053,063,680 bytes
Physical capacity: 8,053,063,680 bytes
Fake/skimpy flash: No
Speed class markings: U1, V10

Sample #	1	2	3	Average
Protected area	0 bytes	50,331,648 bytes (inaccessible)	50,331,648 bytes (inaccessible)	N/A
Manufacturer ID	`0x00`	`0xfe`	`0xfe`	N/A
OEM ID	`0x0000`	`0x3432` (ASCII: `42`)	`0x3432` (ASCII: `42`)	N/A
Product name	`0x534d492020` (ASCII: `SMI`)	`0x5344313647` (ASCII: `SD16G`)	`0x5344313647` (ASCII: `SD16G`)	N/A
Product revision	`0x00`	`0x20`	`0x20`	N/A
Serial number	`0x00000000`	`0x000001af`	`0x000007e1`	N/A
Manufacture date	Sep 2023	Jun 2023	Aug 2023	N/A
Sequential read speed (MB/sec)	17.60	68.44	18.63	34.89
Sequential write speed (MB/sec)	11.13	19.77	18.69	16.53
Random read speed (IOPS/sec)	1,147.21	385.88	375.45	636.18
Random write speed (IOPS/sec)	37.68	172.01	204.32	138.00
Read/write cycles to first error	3,013	5,449	11,821	6,761
Read/write cycles to complete failure	4,773	Not yet determined	Not yet determined	4,773
Total days to complete failure	71	Not yet determined	Not yet determined	71
Card reader used	JJS CR-UTC4AC	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

Auotkn is another brand that came up frequently while browsing AliExpress. The visual design is almost identical to that used by SanDisk's Extreme cards -- to the point where a casual observer from 10 feet away likely wouldn't notice the difference.

I initially found it curious that the first two cards displayed such wildly different results on the performance test. It wasn't until I compared the CID data between the two -- which, admittedly, I didn't do until I was writing this up -- that I noticed that they are completely different. Initially I thought that maybe I got the CID data mixed up with one of my other cards -- after all, card #1 shared the same manufacturer ID, OEM ID, product name, and product revision as the one QEEDNS card I've tested, and sample #2 shared the same values as the Cloudisk and Bekit cards -- but after rechecking the data, it appears that I recorded it correctly the first time. This points to the conclusion that Auotkn may be in the middle of switching manufacturers. Or that they source their cards from multiple manufacturers. Or that they're reselling used cards. On second thought, maybe this doesn't point to any conclusion in particular.

Regardless, the cards have performed well on their endurance tests. All three managed to endure well over 2,000 read/write cycles without any errors, making it only one of two models I've tested so far to do so. As of this writing, samples #2 and #3 are still chugging along: sample #2 has survived 17,954 read/write cycles (and did not experience any errors for the first 5,449 read/write cycles), while sample #3 has survived 12,038 read/write cycles (and did not experience any errors for the first 11,821 read/write cycles).

What's that you say? You want to see a graph showing how many bad sectors were on sample #1 each round? Well OK then, but this one is going to be pretty boring:

This card failed pretty quickly: it experienced a small error (only affecting two sectors) during round 3,013; it then went until round 4,772 without experiencing any more errors. During round 4,772, about 45% of the sectors on the card failed verification; during round 4,773, all of them failed verification -- at which point the 50% failure threshold was reached, and the endurance test was complete.

Overall, while these cards have done well on endurance tests, the tradeoff is speed -- they performed terribly on all of their performance metrics. Don't buy them unless you're willing to deal with that tradeoff.

Last updated: 5/11/2024

Auotkn Extreme 512GB

Advertised capacity: 512GB
Speed class markings: U1, V10

Sample #	1	2	3	Average
Obtained from	AliExpress	AliExpress	AliExpress	N/A
Price paid	$14.26	$13.46	$14.44	$14.05
Manufacturer ID	`0x00`	Unknown	Not yet tested	N/A
OEM ID	`0x0000`	Unknown	Not yet tested	N/A
Product name	`0x4150505344` (ASCII: `APPSD`)	Unknown	Not yet tested	N/A
Product revision	`0x00`	Unknown	Not yet tested	N/A
Serial number	`0x12800003`	Unknown	Not yet tested	N/A
Manufacture date	Mar 2023	Unknown	Not yet tested	N/A
Logical capacity	Unknown	536,871,960,576 bytes	Not yet tested	536,871,960,576 bytes
Physical capacity	Unknown	31,596,637,696 bytes	Not yet tested	31,596,637,696 bytes
Fake/skimpy flash	Unknown	Fake flash	Not yet tested	N/A
Sequential read speed (MB/sec)	Unknown	16.64	Not yet tested	16.64
Sequential write speed (MB/sec)	Unknown	12.54	Not yet tested	12.54
Random read speed (IOPS/sec)	Unknown	1,057.40	Not yet tested	1,057.40
Random write speed (IOPS/sec)	Unknown	0.46	Not yet tested	0.46
Read/write cycles to first error	0	6	Not yet tested	3
Read/write cycles to complete failure	0	164	Not yet tested	82
Total days to complete failure	0	17	Not yet tested	8.5
Card reader used	N/A	Prograde Digital Dual-Slot Mobile Reader	Not yet tested	N/A
Package front			Not yet tested	N/A
Package back			Not yet tested	N/A
Card front			Not yet tested	N/A
Card back			Not yet tested	N/A

Discussion

After deciding to test the Auotkn Extreme 8GB, I purchased a single 512GB card, as I was curious to see if I would find the same manufacturer selling genuine flash and fake flash.

At first, I thought sample #1 was dead on arrival. The card was completely unresponsive whenever I plugged it in. I wasn't sure if these cards were defective by design or if I had simply received a bad card, but I decided to give it the benefit of the doubt and ordered another one -- from a different seller.

Initially, sample #2 was also unresponsive. I was about ready to call it dead on arrival as well, but then I decided to try it with the Prograde reader -- and it worked. Unfortunately, I couldn't use the Prograde reader to read the registers from the card -- I'm only able to do that with the Realtek reader -- so I wasn't able to read the CID data from this card.

As I started working on my FPGA design, however, I decided to try out card #1 to see what it would do when the FPGA tried to initialize it. At first, the FPGA complained that the card sent back a response with a bad CRC. I had my logic analyzer hooked up to it, so I decided to do a capture and look at the communications going between my card and the FPGA. This is the command and response where my FPGA was telling me the response had a bad CRC:

Next, I hooked up one of my working cards and captured the same transaction with that one as well:

If you don't know what you're looking at: the top row (the blue signal) is the clock signal that my FPGA is sending to the card. The bottom row (the green signal) is the "CMD" line -- it's a bidirectional line that the host uses to send commands to the card, and that the card uses to respond to those commands. Coding is NRZL (basically -- a high level represents a 1, a low level represents a 0). In the screenshots, the command and response start at the green dot and end at the red dot.

So as I stared at these captures, I was confused: they looked identical to me. Was the Auotkn sending back voltage levels that were enough for my logic analyzer to detect, but not enough for my FPGA to detect? Was there something wrong with the way I was calculating CRCs? Did a random wire get disconnected from my breadboard?

Eventually I decided to enable the signal tap logic analyzer, which lets you essentially see the signals that the FPGA is seeing -- it's kind of a debugger for the FPGA. I set it to trigger at the point where my card starts to listen for the response from the card, and here's what I got:

What you're seeing in the screenshot above is the FPGA's view of the signals going back and forth over the card's CMD line. The "0" represents the point where it started listening for the reply.

And seeing this, I suddenly realized what the issue was. When the card sends a reply back to the host, it's supposed to start it with 00 (the first bit is a "start" bit, and the other bit indicates the direction -- 0 for card to host, and 1 for host to card). However, my FPGA took a few clock cycles to switch from "sending mode" to "receiving mode", and it didn't have a chance to switch over to "receiving mode" until after the card sent the first bit of its reply back. The card was simply replying back too quickly! I adjusted my design to let the FPGA start listening for the reply sooner -- and whaddya know, it was able to communicate with the card successfully, and I was able to query it for its CID! The CID data I have shown above is what I obtained from this process. I haven't gotten my FPGA design to the point where it can do performance tests, however...so that will have to wait for another day.

This discovery led me to wonder -- did my other card readers have this same deficiency in their design? Were they simply not starting to listen for the card's reply soon enough? As far as I can tell, the SD card specification doesn't say how many clock cycles the card is supposed to wait before replying back to the host, so I imagine the engineers that designed these card reader ICs never had to specifically think about this issue. I imagine I'll probably never know for sure.

As I haven't been able to do performance testing with sample #1, I only have results from sample #2 -- and I have to say, they were pretty unimpressive. Unsurprisingly, this card's physical capacity was not 512GB; its actual capacity was closer to 32GB. The sequential read/write speeds were barely enough to qualify for the U1 and V10 markings that it carries. Additionally, this card only lasted a few read/write cycles before it began showing data mismatch errors; and when it started failing, it failed quickly. By the time the card reached 164 read/write cycles, over half of the sectors on the card had been flagged as bad due to data mismatches.

I do find it interesting to look at exactly what symptoms a card shows when it starts to fail. In this case, some sectors showed a number of bit flips; others simply read back as all ff's.

Here's what the track record for this sample looks like:

As you can see, this sample's endurance test went as follows:

A few rounds of nothing (or practically nothing);
A sudden jump to "halfway to the 50% failure threshold";
A slow rise in the number of bad sectors for about the next 150 read/write cycles;
A sudden jump to "almost 50% of the sectors have failed";
And finally, the card becomes unresponsive.

Given that there are better 32GB cards for less than what I paid, I initially wasn't inclined to buy a third one; however, in the interests of trying to make sure I test at least 3 of each model, I do have a third one in the package waiting to be tested.

Last updated: 3/10/2024

Bekit 8GB

Obtained from: AliExpress
Price paid: $3.46
Advertised capacity: 8GB
Logical capacity: 8,032,092,160 bytes
Physical capacity: 8,032,092,160 bytes
Fake/skimpy flash: No
Protected area: 50,331,648 bytes (inaccessible)
Speed class markings: Class 6, U1
CID data:
- Manufacturer ID: 0xfe
- OEM ID: 0x3432 (ASCII: 42)
- Product name: 0x5344313647 (ASCII: SD16G)
- Product revision: 0x20
- Manufacture date: Nov 2022

Sample #	1	2	3	Average
Serial number	`0x000002c6`	Unknown	`0x00000296`	N/A
Sequential read speed (MB/sec)	90.62	Unknown	87.58	89.10
Sequential write speed (MB/sec)	20.66	Unknown	21.32	20.99
Random read speed (IOPS/sec)	828.80	Unknown	455.90	642.35
Random write speed (IOPS/sec)	236.03	Unknown	187.68	211.86
Read/write cycles to first error	1,572	0	13,758	5,110
Read/write cycles to complete failure	1,582	0	Not yet determined	790
Total days to complete failure	14	0	Not yet determined	7
Card reader used	JJS CR-UTC4AC*	N/A	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

* I think. I didn't specifically write down which card reader I used on any given card, so some of this is going off of memory, and some of it is going off of what the card is plugged into right now.

Discussion

This brand took a little bit more digging to find, but once it came up, the colorful design caught my attention. What can I say. (Squirrel!)

Performance was good enough to merit the speed class marks it bore, and it approached the maximum practical sequential read speed for a UHS-I-compatible card, but sequential write speeds and random I/O speeds were disappointing. Sequential read speeds were above average, but all other performance metrics were below average -- with sample #3 getting a random read speed that was more than one standard deviation below average.

Sample #1 lasted just shy of 1,600 read/write cycles before it failed. Just before failure (starting with round 1,573), it experienced a few rounds where a handful of sectors had data mismatch errors. However, during round 1,583, the device spontaneously changed capacity to 127MB (specifically, to 127,139,840 bytes). At that point, I decided to consider it "dead". I'll note that in versions 2 and 3 of the CSD register specification, the size of the card is indicated by adding 1 to the value of the C_SIZE field, then multiplying it by 524,288. Since 127,139,840 is not a multiple of 524,288, it suggests that (at least) the portion of the card controller's code responsible for populating the CSD register was corrupted, possibly causing it to report that it was using version 1 of the CSD register specification instead.

Here's what the track record for the endurance tests for sample #1 looked like:

Interestingly, sample #2 also reported its capacity as 127MB right out of the package. Given that the other two cards initially reported their capacities correctly -- and the fact that it would not respond to commands when plugged into my Realtek reader -- I decided to declare this card "dead on arrival".

Sample #3, on the other hand, is doing quite well: its first error was a data verification error during round 13,759. It has survived 16,387 read/write cycles so far. So I guess 1 out of 3 is...better than nothing?

Overall, I was impressed by the fact that the card did well on sequential read speeds, but this appears to be where its advantages end. The sequential write speeds and random I/O speeds were all below average, and endurance for 2 out of the 3 cards was below expectations.

My recommendation? Don't buy these. There are better options out there.

Last updated: 5/11/2024

Chuxia 32GB

Obtained from: AliExpress
Price paid: $5.78
Advertised capacity: 32GB
Logical capacity: 31,719,424,000 bytes
Physical capacity: 31,719,424,000 bytes
Fake/skimpy flash: Skimpy (0.88% skimp)
Protected area: 83,886,080 bytes
Adjusted skimp: 0.61%
Speed class markings: Class 10, U1, V10, A1
CID data:
- Manufacturer ID: 0xad
- OEM ID: 0x4c53 (ASCII: LS)
- Product name: 0x5553443030 (ASCII: USD00)
- Product revision: 0x10
- Manufacture date: Apr 2023

Sample #	1	2	3	Average
Serial number	`0x43850827`	`0x43731a75`	`0x43320716`	N/A
Sequential read speed (MB/sec)	51.89	79.66	30.59	54.05
Sequential write speed (MB/sec)	17.96	23.25	18.02	19.74
Random read speed (IOPS/sec)	556.66	4,429.84	444.00	1,810.17
Random write speed (IOPS/sec)	703.03	1,000.08	574.58	759.23
Read/write cycles to first error	1,383	4,338	113	1,945
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	SmartQ Duo	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

Chuxia is another brand that took a little bit more digging to find, but caught my attention because of its original design.

I'm honestly not sure why I got such wildly different results between the different samples, especially on the random read test. If the random read speed for sample #2 is accurate, it would be the highest random read speed of any card I've tested so far. However, the fact that the other two performed so terribly in comparison makes me think that this was a fluke. The CID registers on all three samples were identical (except for the serial number), so I don't think sample #2's results could easily be attributed to a different model or different manufacturer. If you include Sample #2's figures, this card performed average in random read speeds. If you exclude them, this card performed well below average (by more than one standard deviation). Either way you look at it, the card performed below average on sequential read and sequential write speeds, and well above average (more than one standard deviation) on random write speeds. All three performed well enough to qualify for the Class 10, U1, and V10 markings; however, only sample #2 performed well enough for the A1 marking.

All three samples are still undergoing endurance testing; however, the results so far were not too great. Two of the three experienced errors before hitting the 2,000 read/write cycle mark: sample #1 only made it 1,383 read/write cycles before encountering its first error, while sample #3 only made it 113 read/write cycles. Sample #2 is the only one that made it past the 2,000 read/write cycle mark without errors -- it had its first data verification error during round 4,339. As of this writing, sample #1 has survived for 4,500 read/write cycles; sample #2 has survived for 7,240, and sample #3 has survived for 2,362.

Last updated: 5/11/2024

Cloudisk 32GB

Obtained from: AliExpress
Price paid: $3.52
Advertised capacity: 32GB
Logical capacity: 31,457,280,000 bytes
Physical capacity: 31,457,280,000 bytes
Fake/skimpy flash: Skimpy (1.70% skimp)
Protected area: 83,886,080 bytes (inaccessible)
Speed class markings: Class 10, U1, A1
CID data:
- Manufacturer ID: 0xfe
- OEM ID: 0x3432 (ASCII: 42)
- Product name: 0x5344313647 (ASCII: SD16G)
- Product revision: 0x20
- Manufacture date: Jul 2023

Sample #	1	2	3	Average
Serial number	`0x00000ba2`	`0x00000bb4`	`0x00000b9e`	N/A
Sequential read speed (MB/sec)	83.17	37.08	40.36	53.54
Sequential write speed (MB/sec)	23.14	23.75	23.22	23.37
Random read speed (IOPS/sec)	495.66	719.31	540.54	585.17
Random write speed (IOPS/sec)	174.86	143.62	150.28	156.25
Read/write cycles to first error	2,077	1,516	875	1,489
Read/write cycles to complete failure	2,188	2,279	Not yet determined	2,234
Total days to complete failure	142	89	Not yet determined	115.5
Card reader used	SmartQ Duo	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front	Not available			N/A
Package back	Not available	Not available	Not available	N/A
Card front				N/A
Card back				N/A

Discussion

This card was unusual in the fact that it did not come in a retail package -- instead, it came in a simple plastic case.

All three samples performed well enough on the performance tests to qualify for the Class 10 and U1 markings; however, none of them performed well enough to qualify for the A1 marking. As we've established previously, my tests don't conform to the tests described in the SD Physical Layer Specification -- so maybe these cards would have performed better under the right conditions...but somehow I doubt it (especially seeing as how I have other cards that did perform well enough to qualify for the A1 marking).

Sample #1 did make it past the 2,000 read/write cycle mark without encountering any errors -- but just barely. Its track record was pretty boring -- but here it is:

Like I said, it's pretty boring: nothing happens until round 2,077 -- where barely anything happens -- and then nothing happens for another 100 rounds or so before the card becomes unresponsive.

Sample #2 encountered its first error after 1,516 read/write cycles. I finally declared it dead at the end of round 2,279, when the number of bad sectors reached the 50% threshold. Here's what its progress graph looked like:

Sample #3 experienced its first error during round 876. I don't know the nature of the error, but it affected over 5% of the sectors on the device in one round -- but by the next round, those same sectors did not experience any errors. It has survived 2,362 read/write cycles so far.

Last updated: 5/11/2024

Gigastone 32GB

Obtained from: Amazon
Price paid: $6.48
Advertised capacity: 32GB
Logical capacity: Unknown
Physical capacity: Unknown
Fake/skimpy flash: Unknown, but definitely not fake flash
Speed class markings: Class 10, U1
CID data:
- Manufacturer ID: Unknown
- OEM ID: Unknown
- Product name: Unknown
- Product revision: Unknown
- Manufacture date: Unknown
- Serial number: Unknown
Sequential read speed (MB/sec): Unknown
Sequential write speed (MB/sec): Unknown
Random read speed (IOPS/sec): Unknown
Random write speed (IOPS/sec): Unknown
Read/write cycles to first error: 1,785
Read/write cycles to total failure: 1,785
Total days to complete failure: 58
Card reader used: Probably a SmartQ Single
Package front: Not available
Package back: Not available
Card front:
Card back:

Discussion

I had tried to start this project a couple years back, but I lost track of some of the SD cards I purchased for the project. Instead of simply buying new ones, I was determined to figure out what happened to them -- and lost interest in the project after I failed to locate them. Back then, my goals and methods were not as well defined, and thus I don't have as much data on this card as I do on many of the others. This is more of an honorable mention than anything -- however, I did include the endurance data for this card in my overall results.

I'll note that capacity was determined using f3probe, and endurance figures were determined using stressdisk. I don't recall what the card's exact capacity was, only that it was roughly 32GB -- close enough to be considered "not fake flash". In addition, while my other test rigs are laptops using Intel Core i7 processors, this card was tested on a Rock64 single-board computer, so it's possible that CPU speeds could have been a bottleneck on performance. While I didn't run proper speed tests, stressdisk did periodically log the average read/write speeds that it had been seeing -- and the last numbers it recorded before the card failed were a read speed of 80.66MB/sec and a write speed of 23.74MB/sec. If this had represented a proper sequential I/O test, it would put it slightly above average for read speeds, but slightly below average for write speeds. It is good enough to qualify for the Class 10 and U1 markings that it bore.

The notable disadvantage to using stressdisk is that it operates at the filesystem level -- it writes files of a predetermined size to the filesystem, then reads them back in a random order. This means that it's not able to evenly test the entire user area of the flash, as space for things directory structures, file allocation tables, boot sectors, etc., would get written to at a different frequency than the test files. It's possible that this card would have behaved slightly differently -- perhaps it would have failed sooner or later than it did -- had the entire user area of the card been tested evenly instead. Stressdisk also deleted any partial files that it wrote (e.g., due to running out of space on the card) without verifying them -- so any data integrity errors in the portion of the card occupied by that space would have gone undetected. This is not to say that there is not value in testing a card using a tool like stressdisk -- it could be argued that the type of test run by stressdisk better simulates how something like a digital camera or digital video camera would use a card. However, for my purposes, I want to make sure the entire user area of the card is tested. That said, however, this card was able only able to endure 1,785 read/write cycles before it failed. Once it failed, it became completely unresponsive to commands from the reader.

Last updated: 2/25/2024

Hiksemi NEO 8GB

Obtained from: AliExpress
Price paid: $1.03
Advertised capacity: 8GB
Logical capacity: 7,989,624,832 bytes
Physical capacity: 7,989,624,832 bytes
Fake/skimpy flash: Skimpy (0.13% skimp)
Protected area: 134,217,728 bytes
Adjusted skimp: -1.55%
Speed class markings: Class 10
CID data:
- Manufacturer ID: 0x6f
- OEM ID: 0x0303
- Product name: 0x4342414453 (ASCII: CBADS*)
- Product revision: 0x10

* Keen-eyed observers might note that other cards in my survey have a product name of SDABC, and that this is simply that, but backwards. I wonder if there's an inside joke here?

Sample #	1	2	3	Average
Serial number	`0xaa03666f`	`0xaa009e75`	`0xaa00394e`	N/A
Manufacture date	Mar 2023	Mar 2023	Mar 2023	N/A
Sequential read speed (MB/sec)	89.49	91.14	90.62	90.42
Sequential write speed (MB/sec)	47.09	49.37	49.95	48.80
Random read speed (IOPS/sec)	2,150.54	1,607.76	1,626.13	1,794.81
Random write speed (IOPS/sec)	638.39	492.78	335.29	488.82
Read/write cycles to first error	Not yet determined	3	Not yet determined	3
Read/write cycles to complete failure	Not yet determined	5,917	Not yet determined	5,917
Total days to complete failure	Not yet determined	35	Not yet determined	35
Card reader used	SmartQ Duo	JJS CR-UTC4AC*	JJS CR-UTC4AC	N/A
Package front				N/A
Package back	Not available			N/A
Card front				N/A
Card back				N/A

* I think

Discussion

When I first started searching for SD cards on AliExpress, I decided to sort by price from lowest to highest -- and Hiksemi was a result that came up near the top of the list. At the time, they were selling the 8GB card for just $0.01 -- but that was before shipping. Still, I have to say that it's a pretty effective strategy for getting people's attention, and the card is still an excellent value even when factoring in shipping costs.

Honestly, though, I have to say that I was pleasantly surprised by Hiksemi's cards as a whole. This card's only speed class marking is a Class 10 mark, which it easily qualified for. Sequential read and write speeds were well above average (with sequential read speeds being towards the high end of the spectrum). Random read speeds were average (with sample #1 being above average, and samples #2 and #3 being slightly below average), and random write speeds were all above average.

Endurance is where these cards have really shined. As of the time of this writing, sample #1 has survived 49,113 read/write cycles without any errors -- far more than any other card in my collection thus far. (The SanDisk Industrial 8GB #1 is on track to outpace it, but at the rate things are going, this won't happen for almost another two years.) And, at present, this card has gone the longest without errors out of any of the cards in my collection, having gone nearly-continuously for 267 days without experiencing any errors.

Sample #3 has survived 11,345 read/write cycles and has also not experienced any errors.

Sample #2 had a 32 sector data mismatch error during round 3; however, it did not experience any further errors until round 5,918. During this round, a large number of sectors began experiencing data mismatch errors, with a significant portion of those sectors reading back as all 0xff's. The number of sectors that experienced data mismatch errors exceeded 50% of the total sectors on the card during this round, causing the test to end. The progress graph for this sample is going to be pretty boring, but here it is:

Overall, would I buy this cards again? Yes! It was a complete surprise to me, but this card scored above average in every category. The only downside is that it seems that they're no longer available at the price point I bought them at -- there are other sellers on AliExpress that are selling (what appears to be) the same card, but by the time you add in shipping, the price ends up being between 3-6x what I paid.

Last updated: 5/11/2024

Hiksemi NEO 32GB

Obtained from: AliExpress
Logical capacity: 31,271,157,760 bytes
Physical capacity: 31,271,157,760 bytes
Fake/skimpy flash: Skimpy (2.28% skimp)
Protected area: 134,217,728 bytes
Adjusted skimp: 1.86%
Speed class markings: V10
CID data:
- Manufacturer ID: 0x6f
- OEM ID: 0x0305
- Product name: 0x455a534431 (ASCII: EZSD1)
- Product revision: 0x10

Sample #	1	2	3	Average
Obtained from	AliExpress	AliExpress	AliExpress	N/A
Price paid	$1.93	$1.93	$6.61	$3.49
Manufacture date	Apr 2023	Apr 2023	Mar 2023	N/A
Serial number	`0xaa03c26c`	`0xaa020f88`	`0xaa021111`	N/A
Sequential read speed (MB/sec)	89.20	90.85	90.28	90.11
Sequential write speed (MB/sec)	27.10	38.61	22.55	29.42
Random read speed (IOPS/sec)	2,001.52	1,790.34	1,878.15	1,890.00
Random write speed (IOPS/sec)	402.03	360.17	374.97	379.06
Read/write cycles to first error	7,940	1,939	1,392	4,230
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	SmartQ Single	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back	Not available			N/A
Card front	Not available			N/A
Card back	Not available			N/A

Discussion

While not quite as impressive as their smaller siblings, these cards are still pretty impressive overall. Their main disadvantage is that they did markedly worse on sequential write speeds, coming out just "average" in this category. Initially, I only ordered two -- for the simple reason that, at the time, AliExpress would only let me order two. I went back and ordered a third after I made the decision to try to test at least 3 samples of each model.

Sample #1 was initially plugged into a SmartQ Single reader. As I noted earlier, I've had problems with these readers randomly failing every few days -- and this one was no exception. I have code to allow the program to wait for the device to be reconnected and resume the endurance test; however, it took me a while to get the code right. This card did technically suffer some data verification errors, but I chalked them up to cached write losses because of this issue. Its first legitimate error was a four-sector wide data shift error that occurred during round 7,941. As of this writing, it has completed 8,239 read/write cycles in total.

Sample #2 just barely missed the 2,000 read/write cycle mark -- it experienced a 64 sector wide data verification error during round 1,940. It has endured 3,360 read/write cycles total so far.

Sample #3's first error was a four-sector wide data shift error during round 1,324. It has survived 1,602 read/write cycles so far.

Overall, would I buy these cards again? Maybe. They're definitely not a bad card -- they scored about on par with the SanDisk Ultra 32GB (except for random read speeds, where the SanDisk Ultra performed about twice as well), they endured better, and they're priced about the same -- so if you're trying to choose between the two, I think it just depends on whether endurance or random read speeds are more important to you.

Last updated: 5/11/2024

Hiksemi NEO 128GB

Obtained from: AliExpress
Advertised capacity: 128GB
Logical capacity: 125,085,155,328 bytes
Physical capacity: 125,085,155,328 bytes
Fake/skimpy flash: Skimpy (2.28% skimp)
Protected area: 134,217,728 bytes
Adjusted skimp: 2.17%
Speed class markings: V30
CID data:
- Manufacturer ID: 0x6f
- OEM ID: 0x0305
- Product name: 0x455a534431 (ASCII: EZSD1)
- Product revision: 0x10

Sample #	1	2	3	Average
Price paid	$3.89	$3.89	$7.01	$4.93
Serial number	`0xaa005ac1`	`0xaa00b853`	`0xaa00b386`	N/A
Manufacture date	Feb 2023	Feb 2023	Feb 2023	N/A
Sequential read speed (MB/sec)	79.24	91.26	90.05	86.85
Sequential write speed (MB/sec)	50.75	51.03	50.11	50.63
Random read speed (IOPS/sec)	2087.43	1782.33	1906.43	1925.40
Random write speed (IOPS/sec)	438.58	431.70	463.22	444.50
Read/write cycles to first error	2,272	109	Not yet determined	1,191
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	Platinum PT-CRSA1	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

After being initially impressed by the Hiksemi NEO 8GB, I went back to see what other options Hiksemi had available. I must have caught the 128GB while it was on sale (or mispriced), because they were priced at only $1.74 before shipping. Even after shipping, these cards are still an excellent value, coming out to just over 3 cents per gigabyte. The only reason why sample #3 was more expensive is because I gave one to a friend, then went back and re-ordered a replacement; the price had gone up in the meantime.

On the performance front, this is another instance where it feels like Hiksemi undersold the performance of their cards; both samples I've tested so far easily surpassed the benchmark for the V30 mark. Sequential write speeds on all three samples were more than one standard deviation above the average.

All three samples are still undergoing endurance testing. These cards will obviously take longer to complete their endurance test given their size relative to the others in the survey.

Sample #1's first error was a four-sector wide data shift error during round 2,273; it has endured 2,321 read/write cycles in total so far.

Sample #2 experienced a two sector wide data verification error during round 110; it has survived 1,159 read/write cycles in total so far and has not experienced any further errors since then.

Sample #3's first error was an 8-sector wide data verification error during round 515. It has survived 544 read/write cycles in total so far.

Overall, I feel like Hiksemi has been an unexpected standout among the cards I've tested. They're priced very competitively, and perform as well as -- or even better than -- many of their name-brand competitors.

Last updated: 5/11/2024

Kingston Canvas Select Plus 32GB

Advertised capacity: 32GB
Logical capacity: 30,945,574,912 bytes
Physical capacity: 30,945,574,912 bytes
Fake/skimpy flash: Skimpy (3.30% skimp)
Protected area: 83,886,080 bytes (inaccessible)
Speed class markings: Class 10*, U1, V10, A1
CID data:
- Manufacturer ID: 0x27**
- OEM ID: 0x5048 (ASCII: PH)**
- Product name: 0x5344333247 (ASCII: SD32G)
- Product revision: 0x60

* The Class 10 mark appears on the product packaging, but does not appear on the card itself.

** This manufacturer ID/OEM ID is well known to be associated with Phison Electronics Corporation.

Sample #	1	2	3	4	5	6	Average
Obtained from	Amazon	AliExpress	Amazon	AliExpress	Amazon	AliExpress	N/A
Price paid	$8.30	$4.48	$8.30	$4.48	$8.30	$4.48	$6.39
Manufacture date	Feb 2023	May 2023	Feb 2023	May 2023	Feb 2023	May 2023	N/A
Serial number	`0x6c5202a6`	`0x01af9781`	`0x6c5202f6`	`0x01aab823`	`0x6c51ea11`	`0x01af8750`	N/A
Sequential read speed (MB/sec)	91.36	90.92	91.23	86.30	90.83	91.48	90.35
Sequential write speed (MB/sec)	38.28	42.58	36.42	40.62	36.95	40.62	39.25
Random read speed (IOPS/sec)	2215.15	2390.59	2072.70	3729.20	2407.14	2334.70	2524.91
Random write speed (IOPS/sec)	590.49	638.31	580.48	688.02	588.55	633.21	619.84
Read/write cycles to first error	479	3,528	Not yet determined	2,729	126	5	1,373
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	Lexar LRWM05U-7000	JJS CR-UTC4AC	JJS CR-UTC4AC	JJS CR-UTC4AC	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front							N/A
Package back							N/A
Card front							N/A
Card back							N/A

Discussion

I have something of a bias against Kingston cards. I have a number of single-board computers that use microSD cards as their boot device; and while I've typically used SanDisk cards for this, occasionally a Kingston card or two has found its way into the mix, and it seems like the Kingston cards have always failed long before any of the SanDisk cards have. However, these are just anecdotes -- I don't have any hard data to back up the idea that Kingston cards are less reliable than other brands. Because of this, I wanted to give them a fair chance to prove themselves -- so I purchased three from Amazon and three from AliExpress.

The US and Chinese versions of the cards are -- as far as I can tell -- identical. The CID data (with the exception of the manufacture date and serial number) is identical between the two versions. They all performed pretty similarly in performance tests. The exterior also appears to be identical, including this interesting color-shifting stripe on the left edge:

I know that when Bunnie (of Bunnie Studios) went looking for various Kingston cards in the Chinese markets, he described at least one instance where he saw non-Kingston cards being put into Kingston retail packaging -- so I suspect that Kingston did this as a way to assure buyers that these cards were authentic.

The primary difference between the US and Chinese versions seems to be the packaging. And curiously, there's a notable difference here: the US and Chinese versions of the packaging: the Chinese packaging is not tamper-evident. The card can be accessed by opening a simple flap on the front of the package; the card can be replaced, and the flap closed, without causing any damage to the packaging. If I were a retailer selling these in a physical storefront, I'd be forced to have them locked up in some fashion (security box, glass case, behind the counter, etc.) to make sure that unscrupulous customers couldn't come into my store, steal the authentic Kingston cards, and replace them with cheap fakes.

Performance-wise, these cards actually did rather well. All cards scored above average in all performance metrics, with random write speeds for all cards being more than one standard deviation above average. All cards easily met the thresholds for all of the performance marks that they bore (including the A1 mark -- which most cards failed to meet).

These cards are later additions to my collection; as such, they are still undergoing endurance testing. As of this writing:

Sample #1 experienced a data shift error during round 480. It has survived 5,364 read/write cycles in total so far, and has not experienced any further errors since then.
Sample #2 experienced an eight-sector wide data shift error during round 3,529; it has survived 3,596 read/write cycles in total so far.
Sample #3 has survived 3,665 read/write cycles and has not yet experienced any errors.
Sample #4 experienced a data shift error during round 2,729. It has survived 8,634 read/write cycles total so far.
Sample #5 experienced a data shift error during round 127, and experienced a few additional data shift errors in later rounds, but has not experienced any further errors since round 1,941. It has survived 4,380 read/write cycles in total so far.
Sample #6 experienced a data shift error during round 6, and suffered occasional data shift errors in later rounds. It has survived 3,907 read/write cycles in total so far.

So how well have these cards performed overall? Performance-wise, they've done great -- they have some of the fastest random read and write speeds out of any of the cards I've tested. Endurance, however, is another story -- half of them have experienced errors before hitting the 2,000 read/write cycle mark, which is not a particularly great track record. They were also not great for skimp, having one of the highest skimp percentages out of any non-fake card I tested.

Last updated: 5/11/2024

Kioxia Exceria 32GB

Obtained from: Amazon
Price paid: $11.49
Advertised capacity: 32GB
Logical capacity: Unknown
Physical capacity: Unknown
Fake/skimpy flash: Unknown, but definitely not fake flash
Speed class marks*: C10**, U1
CID data:
- Manufacturer ID: Unknown
- OEM ID: Unknown
- Product name: Unknown
- Product revision: Unknown
- Manufacture date: Unknown
- Serial number: Unknown
Sequential read speed (MB/sec): Unknown
Sequential write speed (MB/sec): Unknown
Random read speed (IOPS/sec): Unknown
Random write speed (IOPS/sec): Unknown
Number of read/write cycles to first error: 2,568
Number of read/write cycles to complete failure: 2,568
Total days to complete failure: 66
Card reader used: Probably a SmartQ single
Package front: Not available
Package back: Not available
Card front: Not available
Card back: Not available

* I don't have the card (or the package) any longer, so this information is based on the pictures on Amazon.

** The Class 10 marking appears on the product packaging, but does not appear on the card itself.

Discussion

This card is another one that I purchased a couple years back when I first intended to start this project, so it's primarily here as an honorable mention. I didn't record the card's actual capacity, but I don't recall it being fake flash.

As with the Gigastone card earlier, I used a combination of f3probe and stressdisk to test this card. The logs from stressdisk indicate that the average read speed at the time of failure was 86.74MB/sec, while the average write speed was 18.38MB/sec. While the write speeds are not great, this would be enough to qualify for both the Class 10 and U1 markings. However, keep in mind that this card was tested using an Orange Pi 4 -- so like the Gigastone, it's possible that the limited CPU speed could have been a bottleneck when testing this card.

This card endured 2,568 read/write cycles before failing -- making it past the 2,000 read/write cycle minimum that I've established. The test ended when the card made itself read-only; stressdisk did not note any data mismatch errors before that point. I have to wonder if this was an intended behavior, or if some other issue occurred that caused the card to make itself read-only. If it was an intended behavior, it would be useful in that it would give a user the opportunity to retrieve their data off of a failing card before it failed completely.

Last updated: 2/25/2024

Kioxia Exceria G2 64GB

Obtained from: AliExpress
Price paid: $4.79*
Advertised capacity: 64GB
Logical capacity: 61,891,149,824 bytes
Physical capacity: 61,891,149,824 bytes
Fake/skimpy flash: Skimpy (3.30% skimp)
Protected area: 134,217,728 bytes (inaccessible)
Speed class markings: Class 10, U30, V30, A1
CID data:
- Manufacturer ID: 0x02**
- OEM ID: 0x544d (ASCII: TM)**
- Product name: 0x5345303634 (ASCII: SE064)
- Product revision: 0x89

* The price shown is for the 32GB version. See the discussion for more information.

** This manufacturer ID/OEM ID is well known to be associated with Toshiba/Kioxia.

Sample #	1	2	3	Average
Serial number	`0xf4847fb3`	`0xf484c2b3`	`0xf484c1b3`	N/A
Manufacture date	Oct 2022	Oct 2022	Oct 2022	N/A
Sequential read speed (MB/sec)	87.79	91.11	94.05	90.98
Sequential write speed (MB/sec)	50.93	50.03	62.06	54.34
Random read speed (IOPS/sec)	3416.56	2294.91	2367.29	2692.92
Random write speed (IOPS/sec)	826.33	610.67	683.05	706.68
Read/write cycles to first error	5,109	895	Not yet determined	3,002
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	SmartQ Single	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back	Not available			N/A
Card front				N/A
Card back	Not available			N/A

Discussion

First things first -- I actually ordered the 32GB version; the seller sent me the 64GB version. I don't know if the seller simply made a mistake or if they were out of the 32GB version and sent me the 64GB as a replacement -- but whatever. Free upgrade!

Performance-wise, these cards actually did rather well. All three cards had sequential write and random write speeds that were more than one standard deviation above average. Sample #3 had one of the highest sequential write speeds among the cards that I tested, and sample #1 actually had random write speeds that were more than two standard deviations above average!

As of this writing, all three cards are still undergoing endurance testing:

Sample #1 has experienced errors, but it made it well past the 2,000 read/write cycle mark before doing so -- its first error was during round 5,110, and it has survived 6,192 read/write cycles overall so far.
Sample #2 survived 895 read/write cycles before it experienced a data mismatch error; however, the error only affected 8 sectors and has not recurred since. It has currently survived 3,465 read/write cycles so far.
Sample #3 has survived 2,660 read/write cycles so far, and has yet to experience any errors.

Last updated: 5/11/2024

Kioxia Exceria Plus 32GB

Obtained from: AliExpress
Price paid: $8.19
Advertised capacity: 32GB
Logical capacity: 30,937,186,304 bytes
Physical capacity: 30,937,186,304 bytes
Fake/skimpy flash: Skimpy (3.32% skimp)
Protected area: 83,886,080 bytes
Adjusted skimp: 3.06%
Speed class markings: Class 10*, U3, V30, A1*
CID data:
- Manufacturer ID: 0x02**
- OEM ID: 0x544d (ASCII: TM)**
- Product name: 0x5545304441 (ASCII: UE0DA)
- Product revision: 0x71

* The Class 10 and A1 markings appear on the product packaging, but do not appear on the card.

** This manufacturer ID/OEM ID combination is pretty well known to be associated with Toshiba/Kioxia.

Sample #	1	2	3	Average
Manufacture date	Mar 2020	Mar 2020	Jan 2020	N/A
Serial number	`0xecb7cbb3`	`0xecb7b3b3`	`0xea265bb3`	N/A
Sequential read speed (MB/sec)	74.93	69.04	79.44	74.47
Sequential write speed (MB/sec)	49.34	48.21	46.61	48.05
Random read speed (IOPS/sec)	1,251.78	1,356.44	1,233.83	1,280.68
Random write speed (IOPS/sec)	487.09	530.83	499.95	505.96
Read/write cycles to first error	2,319	2,314	1,611	2,081
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	JJS CR-UTC4AC	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

The Kioxia Exceria G2's performed well in all of the performance tests, which made me curious to see what else Kioxia had to offer.

I was a little surprised to see this card set a new record for skimp in a non-fake flash card, coming at 3.32% -- beating out the previous contender, the Kioxia Exceria G2, at 3.30%. I was also a little surprised to see it perform worse in all performance metrics than the Kioxia Exceria G2. It did, however, perform more than one standard deviation above average in sequential write speeds, and above average in random write speeds, but only average in sequential read speeds and below average in random read speeds.

The card bears the U3 and V30 marks, and performance was enough to qualify for these marks. The package also bears the Class 10 and A1 marks; and while performance was good enough to qualify for the Class 10 mark, it wasn't good enough to qualify for the A1 mark. Interestingly, most other cards that bear the A1 mark have less trouble meeting the threshold for random read operations, and more trouble meeting the threshold for random write operations. This card was the opposite: sample #2 met the 500 random write operations per second threshold, sample #1 came within 3% of that threshold, and sample #3 came just 0.01% short. Random read scores, on the other hand, were farther off the mark.

Endurance tests for these cards are still ongoing:

Sample #1's first error was a four-sector wide data shift error during round 2,319. It has survived 2,374 read/write cycles in total so far.
Sample #2's first error was a 1,568-sector wide data verification error during round 2,315; it has survived 2,364 read/write cycles in total so far.
Sample #3's first error was a four-sector wide data shift error during round 1,612; it has survived 2,021 read/write cycles in total so far.

Overall, this seems to be a decent card. It suffers in read speeds, but it makes up for it by delivering superior write speeds. However, the Kioxia Exceria G2 was cheaper and scored better in all metrics that I measured -- and was almost half the price. If I had to choose between the two in the future, I'd definitely go for the G2 over this one.

Last updated: 5/11/2024

Kodak Ultra Performance 32GB

Advertised capacity: 32GB
Logical capacity: 31,164,727,296 bytes
Physical capacity: 31,164,727,296 bytes
Fake/skimpy flash: Skimpy (2.61% skimp)
Protected area: 83,886,080 bytes
Adjusted skimp: 2.35%
Speed class markings: Class 10, U3, V30, A1
CID data:
- Manufacturer ID: 0x9f
- OEM ID: 0x5449 (ASCII: TI)
- Product name: 0x3030303030 (ASCII: 00000)
- Product revision: 0x00

Sample #	1	2	3	Average
Obtained from	AliExpress	AliExpress	AliExpress	N/A
Price paid	$7.47	$1.79	$1.79	$3.68
Serial number	`0xb8201f91`	`0xba100caa`	`0xbb4010e4`	N/A
Manufacture date	Jun 2023	Jun 2023	Jun 2023	N/A
Sequential read speed (MB/sec)	88.95	83.97	83.37	85.43
Sequential write speed (MB/sec)	13.43	14.27	15.86	14.52
Random read speed (IOPS/sec)	1,709.83	1,663.23	1,506.21	1,626.42
Random write speed (IOPS/sec)	187.58	171.76	169.81	176.38
Read/write cycles to first error	3,530	Not yet determined	Not yet determined	3,530
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	SmartQ Single*	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back	Not available		Not available	N/A
Card front				N/A
Card back				N/A

* I think.

Discussion

When I started this project, I searched for SD cards on AliExpress, then sorted the results in ascending order by price. I believe this is one came up as one of the early results. The price point was a little more than I wanted to pay -- which is why I only ordered one of them initially. (I later decided to try to get 3 of each model, which is why I ordered the other two.) I'll note that many of the results manipulated their position in the search results by including a variation of the product which was simply a microSD-to-SD adapter, which the sellers can afford to sell for a much lower price than the cards themselves -- and which appears as the price for the item in the search results. This is the case on this item as of the time of this writing (with them listing a microSD-to-SD adapter for $0.56, excluding shipping), and I believe it was the case at the time I purchased it.

Performance-wise, this card did well on sequential read performance and average on random read performance, but write performance was disappointing. Both sequential write and random write speeds were below average, with sequential write speeds being more than one standard deviation below average. It did well enough to merit the Class 10 marking that it bears, but not well enough for any of the others. Perhaps it would have done better if it had been tested under the proper test conditions.

Curiously, the 32GB and 64GB versions appear to have been made by different manufacturers, as indicated by the data in their respective CID registers. The 64GB version did markedly better on write performance (although, interestingly, markedly worse on read performance). Both versions are similar in their packaging (although the 64GB version came with a microSD-to-SD adapter, whereas the 32GB version did not), and both bear the information of Dexxon Groupe, indicating (to me, at least) that they were likely sold by Dexxon under license from Kodak. Indeed, their website indicates that they sell storage and IT products for a number of various well-known brands, including Kodak. It appears that Dexxon simply chose different manufacturers for the two versions of this card. It's unclear exactly what the reason for this is.

As of this writing, all three samples are still undergoing endurance testing:

Sample #1's first error was a 6-sector wide data verification error during round 3,531. It has survived 3,981 read/write cycles so far.
Samples #2 and #3 have not yet reached the 2,000 read/write cycle mark. They are currently estimated to get to this point in late August 2024.

Last updated: 5/11/2024

Kodak Ultra Performance 64GB

Advertised capacity: 64GB
Fake/skimpy flash: Skimpy (2.26% skimp)
Protected area: 134,217,728 bytes
Speed class markings: Class 10, U3, V30, A1
CID data:
- Manufacturer ID: 0x6f
- OEM ID: 0x0303
- Product name: 0x5344414243 (ASCII: SDABC)
- Product revision: 0x10

Sample #	1	2	3	Average
Obtained from	AliExpress	AliExpress	AliExpress	N/A
Logical capacity	62,552,276,992 bytes	62,544,412,672 bytes	62,544,412,672 bytes	62,547,034,112 bytes
Physical capacity	62,552,276,992 bytes	62,544,412,672 bytes	62,544,412,672 bytes	62,547,034,112 bytes
Fake/skimpy flash	Skimpy (2.26% skimp)	Skimpy (2.27% skimp)	Skimpy (2.27% skimp)	N/A
Adjusted skimp	2.05%	2.06%	2.06%	2.06%
Price paid	$4.16	$1.79	$1.79	$2.58
Manufacture date	Feb 2023	Jun 2023	Jun 2023	N/A
Serial number	`0xaa000c38`	`0xaa000aeb`	`0xaa0002fb`	N/A
Sequential read speed (MB/sec)	51.79	89.87	89.60	77.09
Sequential write speed (MB/sec)	34.63	39.32	36.85	36.93
Random read speed (IOPS/sec)	2,559.74	1,872.58	1,814.41	2,082.24
Random write speed (IOPS/sec)	554.12	471.09	452.61	492.61
Read/write cycles to first error	2,518	219	728	1,155
Read/write cycles to complete failure	4,240	Not yet determined	Not yet determined	4,240
Total days to complete failure	239	Not yet determined	Not yet determined	239
Card reader used	SmartQ Duo	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

I believe that I found this item as a result of recommendations that AliExpress made while I was looking at the Kodak Ultra Performance 32GB card above. Curiously, they were being sold by different sellers -- sample #1 of the 32GB card was being sold by "Kodak Store", while sample #1 of the 64GB card was being sold by "Kodak Global Store". As I noted above, the two versions also have different manufacturer IDs; however, I'm not convinced that these two facts are related to each other. Additionally, astute readers will note that sample #1 was actually cheaper than sample #1 of the 32GB version. This card was sold with free shipping, while the 32GB card was not; however, even before shipping costs, the 64GB card was still cheaper -- as I paid $4.16 for it, and $5.00 for the 32GB version (before shipping). This price was still above what I wanted to pay at the time, however, so I initially only ordered one of them. (I later decided that I should try to have at least three of each model, and I managed to get them through one of AliExpress's sales.)

Sequential read speeds on sample #1 was disappointing, but samples #2 and #3 were able to make up for it. All other performance metrics were above average for all three samples. Sample #1 met the requirements for all of the speed class markings that it bore; however, samples #2 and #3 fell short of the 500 random write operations per second needed to qualify for the A1 marking. They got close enough, however, that my standard disclaimer of "these cards may have done better had they been tested under proper conditions" might actually have gotten it past the 500 operations per second mark.

On the endurance front: sample #1 made it past the 2,000 read/write cycle mark without errors. It experienced its first error during round 2,518. This error may have been related to the fact that I pulled it from its reader during testing so that I could read the registers off of it with the Realtek reader. However, my program was well into the readback portion of the round when I pulled it -- and section 4.3.3 of the SD Physical Layer Specification says that "[t]he read operation from SD memory card may be interrupted by turning the power off. The SD Memory Card ensures that data is not destroyed during all the conditions except write or erase operations issued by the host even in the event of sudden shut down or removal." Given that my program was only issuing read operations, any data in the card's flash should have long since been written out to the card's flash. Regardless, the symptoms do seem to be consistent with a cached write that was only partially flushed. It also experienced a couple of bit-flip errors affecting two sectors during round 3,903. It finally started experiencing a large number of data loss errors starting in round 4,215; by the end of round 4,241, those errors had affected over 50% of the sectors on the device.

The graph for this card looks pretty boring -- but nevertheless, here it is:

Samples #2's first error was a four-sector wide data shift error during round 219. It has survived 907 read/write cycles in total so far.

Sample #3's first error was a four-sector wide data shift error that occurred during round 729. It has survived 908read/write cycles so far.

Last updated: 5/11/2024

"Lenovo" 128GB

Obtained from: AliExpress
Advertised capacity: 128GB
Fake/skimpy flash: Fake flash
Protected area: 0 bytes
Speed class markings: None

Sample #	1	2	3	Average
Logical capacity	134,218,776,576 bytes	134,217,728,000 bytes	Not yet tested	134,218,252,288 bytes
Physical capacity	8,052,895,232 bytes	8,233,943,040 bytes	Not yet tested	8,143,419,136 bytes
Manufacturer ID	`0x00`	`0x05`	Not yet tested	N/A
OEM ID	`0x0000`	`0x000c`	Not yet tested	N/A
Product name	`0x4150505344` (ASCII: `APPSD`)	`0x6173646667` (ASCII: `asdfg`)	Not yet tested	N/A
Product revision	`0x00`	`0x22`	Not yet tested	N/A
Price paid	$3.98	$3.48	$3.48	$3.65
Manufacture date	Oct 2022	Mar 2024	Not yet tested	N/A
Serial number	`0x12800006`	`0x0000241c`	Not yet tested	N/A
Sequential read speed (MB/sec)	16.51	23.12	Not yet tested	19.82
Sequential write speed (MB/sec)	4.47	4.84	Not yet tested	4.66
Random read speed (IOPS/sec)	1,283.48	1,679.00	Not yet tested	1,481.24
Random write speed (IOPS/sec)	1.01	146.34	Not yet tested	73.68
Read/write cycles to first error	327	Not yet determined	Not yet tested	327
Read/write cycles to complete failure	2,610	Not yet determined	Not yet tested	2,610
Total days to complete failure	163	Not yet determined	Not yet tested	163
Card reader used	SanDisk MobileMate	JJS CR-UTC4AC	Not yet tested	N/A
Package front			Not yet tested	N/A
Package back			Not yet tested	N/A
Card front			Not yet tested	N/A
Card back			Not yet tested	N/A

Discussion

This is one I found while browsing randomly through AliExpress, and one I heavily suspected would be fake flash when I ordered it. I was curious to see whether lower and higher capacity models would both be fake flash, or if these sellers would limit their fake flash to just higher capacity models -- so I bought a single 128GB card (which was the lowest capacity they offered) and a single 2TB card. Later, after I made the decision to test at least three samples of each brand/model/capacity, I went back and ordered two more. Unfortunately, the seller sent me 256GB cards, so I had to order another two from a different seller. Spoiler: they're all fake flash.

Disclaimer: I don't think Lenovo had anything to do with this card. I think this is an unlicensed knock-off (hence why "Lenovo" is in quotes).

I've noticed a number of trends with some (though not all) fake flash. For example, many fake flash cards bear the name of well-known electronics manufacturer, even though the manufacturer is not known for selling SD cards. (For example, I've obtained cards bearing the names of Lenovo, Sony, and Xiaomi.) Most of them -- or at least, the ones I've been able to read the CID data from -- have had their manufacturer ID set to 00 and their OEM ID set to 0x0000, presumably to hide the identity of their manufacturer. Additionally, these cards also tend to have pretty abysmal performance across the board. This card is no exception: all performance results have been below average, with most results being more than one standard deviation below average.

This particular seller also attempted to be sneaky by not including any of the standard speed class marks. Instead, they opted to include the Nintendo Switch icon instead -- which, last I checked, wasn't an indicator of speed. (They did include the UHS-I mark, but this mark by itself doesn't make any assertions as to the card's read or write speeds.)

Sample #1 chugged along on its endurance test for quite some time; however, it only managed to go 327 read/write cycles before starting to display data mismatch errors. At first, the errors only affected two sectors; however, the number of sectors increased nearly every round after that. (Almost all of these errors have been bit-flip errors.)

This eventually caused problems for my code's device detection logic: the program keeps a copy of the data that it wrote to two fixed segments on the card. When a device is disconnected and reconnected, or when the program is interrupted and restarted, it tries to automatically identify which device it was testing, and it reads back the contents of both of those segments as part of that process. However, this card had so many sectors go bad that both of those segments quickly became unstable. When an issue occurred, I had to restart the endurance test from scratch. (I plan to add some strategies to work around this at some point in the future.)

Sample #1 spent most of its endurance test in one of the SanDisk MobileMate readers. However, as a JJS CR-UTC4AC reader became available, I moved it to one of those readers. This, of course, necessitated the restart of the endurance test. Strangely, on the first round of the endurance test, large portions of the card that had been marked as bad in other tests passed verification; however, the remainder of the card failed verification. At this point, over 50% of the sectors on the card had been flagged as bad, and the endurance test was ended.

Sample #2 recently started endurance testing and has not yet reached the 2,000 read/write cycle mark.

Sample #3 is still in the package waiting to be tested.

Last updated: 5/10/2024

"Lenovo" 2TB

Obtained from: AliExpress
Advertised capacity: 2TB
Logical capacity: 2,147,483,648,000 bytes
Physical capacity: 8,032,673,792 bytes
Fake/skimpy flash: Fake flash
Protected area: 0 bytes
Speed class markings: None
CID data:
- Manufacturer ID: 0x00
- OEM ID: 0x0000
- Product name: 0x0000000000
- Product revision: 0x00

Sample #	1	2	3	Average
Price paid	$4.27	$3.33	$3.33	$3.64
Manufacture date	Aug 2023	Not yet tested	Not yet tested	N/A
Serial number	`0x000040a4`	Not yet tested	Not yet tested	N/A
Sequential read speed (MB/sec)	21.05	Not yet tested	Not yet tested	21.05
Sequential write speed (MB/sec)	12.91	Not yet tested	Not yet tested	12.91
Random read speed (IOPS/sec)	1,289.84	Not yet tested	Not yet tested	1,289.84
Random write speed (IOPS/sec)	0.91	Not yet tested	Not yet tested	0.91
Read/write cycles to first error	5,601	Not yet tested	Not yet tested	5,601
Read/write cycles to complete failure	11,633	Not yet tested	Not yet tested	11,633
Total days to complete failure	162	Not yet tested	Not yet tested	162
Card reader used	SanDisk MobileMate	Not yet tested	Not yet tested	N/A
Package front		Not yet tested	Not yet tested	N/A
Package back		Not yet tested	Not yet tested	N/A
Card front		Not yet tested	Not yet tested	N/A
Card back		Not yet tested	Not yet tested	N/A

Discussion

As with the 128GB above, I wanted to get a card that was obviously fake flash and one that could have been ambiguous to see if only one would be fake, or if they would both be fake. It turns out they were both fake. (I later purchased two additional samples after deciding that I should try to have at least three samples of each model that I'm testing.)

Disclaimer: I don't believe Lenovo had anything to do with this card. I think this is an unlicensed knock-off (hence why "Lenovo" is in quotes).

This card continues the fake flash trend of terrible performance. While it did better on the sequential I/O tests than its 128GB sibling, it did about the same on the random I/O tests. All results were below average, and with the exception of the random read test, all results were more than one standard deviation below average. As with the 128GB card, the seller only put the UHS-I mark on this card -- there are no speed class marks to test for.

Surprisingly, however, this card endured far better than its smaller sibling: it completed 5,601 read/write cycles before showing any errors. Curiously, when data mismatch errors occurred, they were mostly happening as a single group of 64 contiguous sectors -- with the data read not at all seeming to resemble the data written -- which are then separated by a number of read/write cycles where no data mismatch errors occur. The number of rounds between data mismatch errors seemed to be random, ranging from as few as 5 to as many as 625. This implies to me that the card was employing some sort of wear leveling (probably dynamic wear leveling), the bad sectors weren't being detected by the card, and the card was simply recycling the bad sectors as part of its wear leveling algorithm.

During round 11,626, it started experiencing a number of missing data errors; however, the number of sectors affected during this round -- as well as the next 5 rounds -- represented only a fraction of a percent of the total sectors on the device. However, this escalated during round 11,632 -- during this round, the total number of bad sectors on the device went from 0.126% to 3.52%. By the end of round 11,633, that number shot up 43.089%. Sometime during round 11,634, the card stopped responding to commands altogether, and the endurance test was considered complete at that point.

So...while this card was much smaller than advertised and performed terribly, I'm forced to conclude that it was more reliable than average. However, this was only one card: I have two more samples in the package waiting to be tested -- we'll have to see how well they do.

Last updated: 4/20/2024

Lexar Blue 633x 32GB

Obtained from: AliExpress
Price paid: $1.99
Advertised capacity: 32GB
Logical capacity: 31,719,424,000 bytes
Physical capacity: 31,719,424,000 bytes
Fake/skimpy flash: Skimpy (0.88% skimp)
Protected area: 83,886,080 bytes
Adjusted skimp: 0.61%
Speed class markings: Class 10*, U1, V10, A1
CID data:
- Manufacturer ID: 0xad
- OEM ID: 0x4c53 (ASCII: LS)
- Product name: 0x4c58333247 (ASCII: LX32G)
- Product revision: 0x10

Sample #	1	2	3	Average
Serial number	`0x3a0097a2`	`0x41b403fd`	`0x41af03f6`	N/A
Manufacture date	Aug 2023	Aug 2023	Aug 2023	N/A
Sequential read speed (MB/sec)	89.89	90.49	90.10	90.16
Sequential write speed (MB/sec)	28.66	28.30	27.92	28.29
Random read speed (IOPS/sec)	2,446.17	2,411.09	2,475.37	2,444.21
Random write speed (IOPS/sec)	698.86	668.24	677.34	681.48
Read/write cycles to first error	157	267	2,057	827
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	JJS CR-UTC4AC	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

By mid-January 2024, I had started endurance testing on two of the Lexar Professional 1000x 64GB cards, and it became obvious that these cards had a pretty significant data integrity issue (see the discussion on those cards for more info). However, seeing as those were the only Lexar cards in my collection, I thought that it would be a pretty poor representation of Lexar as a whole -- so I decided it would be good to include another Lexar model.

There's one particular data point that strikes me as odd: the manufacturer ID. None of the sources I looked at listed manufacturer ID 0xad as belonging to Lexar -- or anyone at all. This manufacturer ID is shared by two other brands in my collection: Chuxia and OV. In fact, all three not only had the same manufacturer ID, but also the same OEM ID. This could be a sign that these cards were fake; however, I didn't see any other signs indicating that the card is fake -- capacity is as advertised, and printing (on both the card and the packaging) was clear and high quality. The markings on the back of the card appear to have been printed on -- as opposed the Lexar Professional 1000x 64GB, where it appears the markings were laser-etched -- but this is about the only inconsistency I could spot off the bat. If this is a fake, it's a pretty convincing fake.

However, I think there's a more mundane explanation. The Lexar Professional 1000x 64GB cards have manufacture dates of Jan 2017 and Feb 2017, while these cards have a manufacture date of Aug 2023. Lexar was owned by Micron up until August of 2017, when they made the decision to sell the Lexar brand name to Shenzhen Longsys Electronics Co. -- meaning that the two Lexar Professional 1000x 64GB cards would have been made by Micron, and these two would have been made by Longsys. Given that, I think manufacturer ID 0xad is probably assigned to Longsys.

Performance-wise, these cards did above average in all categories except sequential write speeds, which were slightly below average. However, random write speeds -- a category which a lot of cards struggled with -- were more than one standard deviation above average. These cards easily surpassed the thresholds for all of the speed class marks that they bore. Honestly -- not bad for a card that was only $1.99.

All three samples are still undergoing endurance testing:

Sample #1's first error was a data shift error during round 158; it has survived 3,176 read/write cycles so far.
Sample #2's first error was a data shift error during round 268; it has survived 2,250 read/write cycles so far.
Sample #3 was the only one of the three that managed to survive for at least 2,000 read/write cycles before experiencing its first error, which was -- you guessed it -- a data shift error during round 2,058. It has survived 2,420 read/write cycles so far.

Last updated: 5/11/2024

Lexar Professional 1000x 64GB

Obtained from: Amazon
Advertised capacity: 64GB
Fake/skimpy flash: No
Protected area: 134,217,728 bytes
Speed class markings: Class 10, U3

* This manufacturer ID/OEM ID is well known to be associated with Lexar.

Card #	1	2	3	Average
Price paid	$13.99	$12.99	$11.95	$12.98
Logical capacity	64,087,916,544 bytes	64,087,916,544 bytes	64,172,851,200 bytes	64,116,228,096 bytes
Physical capacity	64,087,916,544 bytes	64,087,916,544 bytes	64,172,851,200 bytes	64,116,228,096 bytes
Adjusted skimp	-0.35%	-0.35%	-0.48%	-0.39%
Manufacturer ID	`0x28`*	`0x28`*	`0x27`**	N/A
OEM ID	`0x4245` (ASCII: `BE`)*	`0x4245` (ASCII: `BE`)*	`0x5048` (ASCII: `PH`)**	N/A
Product name	`0x363842484f` (ASCII: `68BHO`)	`0x363842484f` (ASCII: `68BHO`)	`0x3659444c50` (ASCII: `6YDLP`)	N/A
Product revision	`0x08`	`0x08`	`0x07`	N/A
Manufacture date	Jan 2017	Feb 2017	Apr 2017	N/A
Serial number	`0x663b0e7f`	`0x863b1c8f`	`0xda874480`	N/A
Sequential read speed (MB/sec)	164.16	170.52	151.99	162.22
Sequential write speed (MB/sec)	35.49	35.89	49.97	40.45
Random read speed (IOPS/sec)	2883.53	1,050.90	2,336.09	2,090.17
Random write speed (IOPS/sec)	125.79	231.28	584.21	313.76
Read/write cycles to first error	0	0	163	54
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	Lexar LRWM05U-7000	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

* This manufacturer ID/OEM ID combination is pretty well known to be associated with Lexar.

** This manufacturer ID/OEM ID combination is pretty well known to be associated with Phison.

Discussion

Oh boy, do I have a thing or two to say about these cards. So here we go.

I purchased sample #1 because I wanted to be able to have at least one UHS-II card in my results. UHS-II cards tend to be pretty expensive (comparatively speaking), which is why I initially only ordered one. It came in retail packaging, complete with a Lexar LRWM05U-7000 UHS-II card reader, and I initially planned to test it with this card reader -- but fate (or Lexar?) apparently had other ideas. It almost immediately had issues, unable to make it through even its authenticity or performance tests. After a few tries, I was able to get it to complete both tests -- but I found that it was much more stable when I switched it over to another reader, so I gave up on the Lexar LRWM05U-7000 and put it into a JJS CR-UTC4AC instead.

I bought the first of these cards because I wanted to be able to have at least one UHS-II card in my results. UHS-II cards tend to be pretty expensive (comparatively speaking), so I initially only ordered one. It arrived in retail packaging, which included a Lexar LRWM05U-7000 UHS-II card reader. I planned to test it using this card reader; however, it started to experience I/O errors soon after tests began. On the next attempt, I was able to get it to complete its authenticity and performance tests; but it then started experiencing I/O errors during the first round of endurance testing. Restarting the endurance test didn't seem to help -- so I decided to move it to one of the JJS CR-UTC4ACs instead.

The I/O errors stopped under the JJS reader, but then a different issue surfaced: in every round of the endurance test, there would be a handful of data verification failures. But when I looked at the data being read back and compared it to what was being written to the card, I noticed something odd. Here's a snippet of my logs -- see if you can spot the issue:

[Sat Nov 11 02:19:40 2023] Expected data was:
[Sat Nov 11 02:19:40 2023] 00000009e2a70200: 3e 78 78 ef e5 e9 fe cc 42 60 17 ae b7 6a 4f a6
[Sat Nov 11 02:19:40 2023] 00000009e2a70210: dd d6 24 cc 5c 53 f0 f4 16 47 f8 e5 80 04 47 df
[Sat Nov 11 02:19:40 2023] 00000009e2a70220: 51 9b cc 84 03 85 8e f0 aa c5 2a d4 72 c7 35 97
[Sat Nov 11 02:19:40 2023] 00000009e2a70230: af e9 18 b3 7d ad 77 a4 5b 31 f4 fe d1 e0 75 e2
...

[Sat Nov 11 02:19:40 2023] Actual data was:
[Sat Nov 11 02:19:40 2023] 00000009e2a70200: 3e 78 78 ef e5 e9 fe cc 42 60 17 ae b7 6a 4f a6
[Sat Nov 11 02:19:40 2023] 00000009e2a70210: 7f 45 ea b4 5c 53 f0 f4 16 47 f8 e5 80 04 47 df
[Sat Nov 11 02:19:40 2023] 00000009e2a70220: 51 9b cc 84 03 85 8e f0 aa c5 2a d4 72 c7 35 97
[Sat Nov 11 02:19:40 2023] 00000009e2a70230: af e9 18 b3 7d ad 77 a4 5b 31 f4 fe d1 e0 75 e2
...

And another mismatch that happened a couple weeks later:

[Wed Nov 29 05:10:17 2023] Expected data was:
[Wed Nov 29 05:10:17 2023] 000000034dafc200: db cb 0e bb 8e 05 2b b4 c0 80 c0 f9 5e ca 84 bd
[Wed Nov 29 05:10:17 2023] 000000034dafc210: 38 88 89 c0 8f 4c eb c9 43 1a df b9 fc 8a 84 df
[Wed Nov 29 05:10:17 2023] 000000034dafc220: 39 e2 88 ce fc 87 4d a9 11 e9 70 be eb 85 53 8e
[Wed Nov 29 05:10:17 2023] 000000034dafc230: 20 8a 3d c2 03 5b ee e4 cd f2 ed ac 55 1a 70 aa
...

[Wed Nov 29 05:10:17 2023] Actual data was:
[Wed Nov 29 05:10:17 2023] 000000034dafc200: db cb 0e bb 8e 05 2b b4 c0 80 c0 f9 5e ca 84 bd
[Wed Nov 29 05:10:17 2023] 000000034dafc210: f6 19 bb eb 8f 4c eb c9 43 1a df b9 fc 8a 84 df
[Wed Nov 29 05:10:17 2023] 000000034dafc220: 39 e2 88 ce fc 87 4d a9 11 e9 70 be eb 85 53 8e
[Wed Nov 29 05:10:17 2023] 000000034dafc230: 20 8a 3d c2 03 5b ee e4 cd f2 ed ac 55 1a 70 aa
...

See that? It's always bytes 16-19 that are mismatched. Every. Single. Time.

"OK", I thought to myself, "maybe I just got a bad card. It happens. I'll just order another one." So I did, and from the same Amazon seller. This one looked pretty much identical to the first one, complete with another Lexar LRWM05U-7000 card reader. This time, I decided to set that one aside, and I put it straight into one of the JJS CR-UTC4AC readers. And as soon as the endurance test started running? It started having the same issue -- right down to the same four bytes being mismatched:

[Mon Nov 20 20:36:07 2023] Expected data was:
[Mon Nov 20 20:36:07 2023] 00000001e4b04200: 2c 7d 0a a6 e0 d2 23 8f b6 9b f3 0a 44 f8 6b a2
[Mon Nov 20 20:36:07 2023] 00000001e4b04210: 9c 4e d8 fe 8e 51 ae 43 b1 62 fe b8 aa 3d 6c 77
[Mon Nov 20 20:36:07 2023] 00000001e4b04220: 39 f8 4f 95 15 43 c2 9d 8f f6 5b 82 57 32 85 e4
[Mon Nov 20 20:36:07 2023] 00000001e4b04230: 09 79 d8 bb 17 70 11 ff 68 97 be 96 a3 d9 c5 8d
...

[Mon Nov 20 20:36:07 2023] Actual data was:
[Mon Nov 20 20:36:07 2023] 00000001e4b04200: 2c 7d 0a a6 e0 d2 23 8f b6 9b f3 0a 44 f8 6b a2
[Mon Nov 20 20:36:07 2023] 00000001e4b04210: 61 1a 0b 86 8e 51 ae 43 b1 62 fe b8 aa 3d 6c 77
[Mon Nov 20 20:36:07 2023] 00000001e4b04220: 39 f8 4f 95 15 43 c2 9d 8f f6 5b 82 57 32 85 e4
[Mon Nov 20 20:36:07 2023] 00000001e4b04230: 09 79 d8 bb 17 70 11 ff 68 97 be 96 a3 d9 c5 8d
...

This was too weird to be coincidence. I considered that maybe they were both part of the same batch, and that there was an issue with that particular batch -- but the two cards have different manufacturing dates (and wildly different serial numbers). That means that either there was a manufacturing issue that went undetected for multiple batches, or there's a design flaw with this card.

For a while, I was going to leave it at that; but at some point, I decided that I should try to have at least three samples of all the cards I'm testing -- so I went back to the same Amazon seller and ordered a third one. Here's where the story took a twist: the product packaging was identical, it included another Lexar LRWM05U-7000 card reader, the card design was the same -- but the CID data indicates that it's a completely different card! Every single field in the CID register was different from the other two samples. The manufacturer ID indicates that it was made by Phison -- which has been known to make Lexar-branded cards in the past (at least, according to CameraMemorySpeed.com) -- so my guess is that Lexar simply contracted out part of the production of these cards to Phison.

The package advertises read speeds of up to 150MB/sec and write speeds of up to 45MB/sec. All three samples managed to surpass 150MB/sec on sequential read speeds (putting it more than 2 standard deviations above average), but only sample #3 (the Phison-produced sample) managed to hit the 45MB/sec mark on sequential write speeds. Samples #1 and #2 ended up being just slightly above average in this category; sample #3 ended up being more than one standard deviation above average.

Random I/O speeds were pretty inconsistent. When tested with the Lexar LRWM05U-7000, sample #1 got random read speeds that were more than one standard deviation above average. However, the same card, tested on the same machine with a JJS CR-UTC4AC, only managed to get about 1/4 of that. Both random read speeds and random write speeds ran the gamut from "well below average" to "more than one standard deviation above average", depending on the card. I can't say for sure whether the Phison-produced samples or the Lexar-produced samples were better for random read speeds, but it did seem like the Phison-produced sample was significantly better for random write speeds.

All three samples scored well enough to merit the Class 10 and U3 markings; but frankly, I would have expected better for a name-brand card that had "Professional" as part of its name -- especially when there are UHS-I cards that were able to get better write speeds.

All three samples are still undergoing endurance testing:

Sample #1 has survived 1,610 read/write cycles so far.
Sample #2 has survived 2,582 read/write cycles so far. (I find it curious that sample #2 has outpaced sample #1 -- they're both hooked up to the same machine, to identical card readers. However, sample #1 is averaging about 8.66 read/write cycles per day, while sample #2 is averaging about 14.92 read/write cycles per day. I don't know why.)
Sample #3 has survived 1,160 read/write cycles so far.

Of course, there's one more strangeness to add to this whole thing: by round 294, the errors with sample #1 stopped completely, and did not recur until round 988. Did the card's wear leveling algorithm simply rotate these bad sectors out into its spare space for those intervening 700-ish rounds? Or was some other factor at work here? (It's times like these that make me wish I could see into what's going on inside the microSD card...) Meanwhile, sample #2 is still turning up a handful of errors almost every round.

The Phison-produced sample, on the other hand, has not had quite the same issues that the Lexar-produced samples did. This sample managed to go 163 read/write cycles before its first error -- a four-sector wide data shift error. It experienced another data shift error -- this time affecting six sectors -- during round 173, but has not experienced any further errors since then.

Overall, however, I wouldn't recommend buying this card. While some of the performance metrics were good-to-impressive, it doesn't make up for the data integrity issues that I encountered on the two Lexar-produced samples. As evidenced by the fact that I bought all three samples from the same seller and got two different cards, I think it's fair to say that if you purchased one of these, there would be no way of knowing beforehand whether you were going to get a Lexar-produced card or a Phison-produced card. Had I used this in a digital camera and gone on a photo shoot, it's likely that some of my pictures would have been corrupted the very first time I used the card -- and any photographer will tell you that's just not acceptable.

Last updated: 5/11/2024

Microdrive "Bart Simpson" 16GB

Obtained from: AliExpress
Price paid: $2.89
Advertised capacity: 16GB
Protected area: 134,217,728 bytes
Speed class markings: Class 10, U1
CID data:
- Manufacturer ID: 0x6f
- OEM ID: 0x0303
- Product name: 0x5344414243 (ASCII: SDABC)
- Product revision: 0x10

Card #	1	2	3	Average
Logical capacity	15,732,310,016 bytes	15,732,310,016 bytes	15,847,653,376 bytes	15,770,757,802 bytes
Physical capacity	15,732,310,016 bytes	15,732,310,016 bytes	15,847,653,376 bytes	15,770,757,802 bytes
Fake/skimpy flash	Skimpy (1.67% skimp)	Skimpy (1.67% skimp)	Skimpy (0.95% skimp)	N/A
Adjusted skimp	0.83%	0.83%	0.11%	0.59%
Manufacture date	May 2023	Jan 2013	Jun 2023	N/A
Serial number	`0xaa0000b0`	`0xaa00038e`	`0xaa000189`	N/A
Sequential read speed (MB/sec)	64.19	79.70	89.38	77.76
Sequential write speed (MB/sec)	23.25	17.65	49.95	30.28
Random read speed (IOPS/sec)	1,562.66	1,722.91	1,665.23	1,650.27
Random write speed (IOPS/sec)	378.03	214.84	542.5	378.46
Read/write cycles to first error	4,270	Not yet determined	Not yet determined	4,270
Read/write cycles to complete failure	8,570	Not yet determined	Not yet determined	8,570
Total days to complete failure	183	Not yet determined	Not yet determined	183
Card reader used	Prograde Digital Dual Slot Mobile Reader	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front	Not available			N/A
Package back	Not available			N/A
Card front				N/A
Card back				N/A

Discussion

This is a card that I bought during my first round of SD card purchases from AliExpress, and I very clearly remember the thing that stood out to me about these cards: Bart Simpson peeking in from the side of the card. I'm sure Fox would love to hear about this.

Now, a disclaimer: I think these were made by Microdrive, but I'm not 100% certain. The card itself doesn't have any brand name on it, and neither does the package it came in -- it came in a generic red package that had no brand name, no indication of the size of the card in the package, no speed markings, and no manufacturer information. It's substantially identical to the packaging that the Auotkn, knockoff Lenovo, QEEDNS, and knockoff Sony cards came in. (What's funny to me is that the package has a telephone icon that says "tech support" above it, but there's no indication of where to go to get said tech support -- there are no websites, no phone numbers, no mailing addresses...nothing.) However, these cards came from an AliExpress store called "MD Factory Promotional Store", and many of the other products they sell are Microdrive branded -- so I'm choosing to believe that these cards were made by Microdrive as well. For the longest time, I had these in my list as simply "Unbranded Simpsons card" because I wasn't 100% sure they were Microdrive cards.

Curiously, sample #2's CID data indicated a manufacturing date of January 2013 -- which would have been more than 10 years before I purchased it -- while samples #1 and #3 had more recent dates of May 2023 and June 2023, respectively. When I noticed this, I went back and re-read the CID from the card to make sure I hadn't made a mistake (such as transcribing the CID value to my spreadsheet by hand and mistyping something) -- but alas, I had it correct the first time. Given that sample #2's packaging didn't make it look like it had been sitting around for 10 years, I'm inclined to think that its manufacture date was a mistake, and that it was actually made more recently.

Performance-wise, these cards did OK. Not great, just OK. Sequential read speeds, random read speeds, and random write speeds were close to average, while sequential write speeds were below average. However, despite being just OK, it was good enough to qualify for the Class 10 and U1 markings that it carried.

Endurance-wise -- these cards actually did pretty well. All three samples made it past the 2,000 read/write cycle mark without errors, making it only one of three models I've tested to do so. Samples #2 and #3 are still going; sample #2 has gone 6,610 read/write cycles thus far, while sample #3 has gone 5,275. Neither has experienced any errors so far.

Overall, I think I'm forced to conclude that these are decent cards. They're not the best performers in terms of read/write speeds (although sample #3 bucked that trend), but so far they seem to have endured pretty well -- sample #1 was the worst performer in this area, and it survived 4,270 before it encountered its first error. Some of the "high endurance" cards I've tested have been rated for over 6,000 read/write cycles -- so while these cards probably wouldn't cut it as high endurance cards, they certainly come close (and have fared much better than some other cards I've tested).

Last updated: 5/11/2024

Netac PRO 16GB

Obtained from: AliExpress
Price paid: $1.99
Advertised capacity: 16GB
Logical capacity: 15,942,025,216 bytes
Physical capacity: 15,942,025,216 bytes
Fake/skimpy flash: Skimpy (0.36% skimp)
Protected area: 134,217,728 bytes
Adjusted skimp: -0.48%
Speed class markings: U1*, V10, A1
CID data:
- Manufacturer ID: 0x6f
- OEM ID: 0x0303
- Product name: 0x4342414453 (ASCII: CBADS)
- Product revision: 0x10

* The U1 mark only appears on the card -- it does not appear on the packaging.

Sample #	1	2	3	Average
Manufacture date	Jun 2023	Jun 2023	Jun 2023	N/A
Serial number	`0xaa000667`	`0xaa0004c7`	`0xaa00068a`	N/A
Sequential read speed (MB/sec)	28.40	24.19	17.00	23.20
Sequential write speed (MB/sec)	21.35	20.13	21.53	21.00
Random read speed (IOPS/sec)	1,192.89	1,283.40	794.84	1,090.38
Random write speed (IOPS/sec)	263.39	262.16	234.16	253.24
Read/write cycles to first error	2,109	Not yet determined	Not yet determined	2,109
Read/write cycles to complete failure	2,109	Not yet determined	Not yet determined	2,109
Total days to complete failure	47	Not yet determined	Not yet determined	47
Card reader used	JJS CR-UTC4AC	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

Netac has the special distinction of being the first brand I've come across where the card was actually bigger than what was advertised. Note that it's not this card -- I received an 8GB Netac card (not the Pro) with my 3D printer. Upon closer inspection, however, I found that the card had only been partitioned to 8GB -- and was, in fact, a 16GB card. I'll admit that it did make me a little curious to see if any of Netac's other cards would be the same way.

I've only tested one of these cards so far, but the results from sample #1 were disappointing. All performance metrics were below average, with sequential read speeds being more than one standard deviation below average. It's enough to qualify for the U1 and V10 markings, but both of the random I/O metrics fell short of what's required for the A1 marking. I'll throw in my standard "perhaps this card would have performed better if it had been tested under proper conditions" disclaimer. Who knows -- I have two more samples left to test. Maybe one of them will do better.

Sample #1 did manage to pass the 2,000 read/write cycle mark without issues. Curiously, however, it randomly disconnected itself during round 2,110. When I went to pull it from the reader and put it back in, it suddenly registered as a 2GB card instead of a 16GB card. After verifying this with the Realtek reader, I decided to declare this card "dead".

Since this card was still responding to commands, and since I had dumped the CID, CSD, SSR, and SCR registers before starting any sort of testing on it, I decided to dump them again and compare the two. There were stark differences between the two: the SSR was now reading as all zeroes, and the other registers' values had now changed almost completely:

Register	Value Before	Value After
CID	`6f0303434241445310aa000667017601`	`8903034e43617264101930291200a101`
CSD	`400e00325b59000076c67f800a404001`	`0026ff325f5a83b92db7ff9f96400001`
SCR	`02b5800300000000`	`0225000000000000`

In the "after" values, the OEM ID and hardware revision ID had somehow managed to escape unchanged, but almost all other values didn't: the manufacturer ID changed to 0x89 (which mmc-utils has listed as "Unknown"), the product ID had changed to NCard (?????), the serial number was completely different, and the manufacture date had changed to January 2010. Normally I would just assume that these values were being stored in the card's flash (although probably a different section of flash than the flash core) and that this portion of the flash had become corrupted -- but the fact that the product ID changed to NCard really struck me as odd. The values in the CSD register seem...sane-ish. So...did this card's controller have some default values programmed into it, and for some reason it reverted to those values? Did it have an entire backup program that it reverted to using?? I might never know for sure.

Samples #2 and #3, meanwhile, have not yet reached the 2,000 read/write cycle mark. They're currently expected to reach this point sometime in June 2024.

Last updated: 5/5/2024

OV 32GB

Obtained from: AliExpress
Price paid: $5.48
Advertised capacity: 32GB
Logical capacity: 31,719,424,000 bytes
Physical capacity: 31,719,424,000 bytes
Fake/skimpy flash: Skimpy (0.88% skimp)
Protected area: 83,886,080 bytes
Adjusted skimp: 0.61%
Speed class markings: Class 10, U1*, U3, V10*, V30, A1*, A2**
CID data:
- Manufacturer ID: 0xad
- OEM ID: 0x4c53 (ASCII: LS)
- Product name: 0x5553443030 (ASCII: USD00)
- Product revision: 0x10

* The U1, V10, and A1 marks only appear on the packaging -- they do not appear on the card.

** The A2 mark only appears on the card -- it does not appear on the packaging.

Card #	1	2	3	Average
Manufacture date	Mar 2023	Mar 2023	Mar 2023	N/A
Serial number	`0x41bf31be`	`0x41bf3240`	`0x41b91835`	N/A
Sequential read speed (MB/sec)	40.98	62.12	51.97	51.69
Sequential write speed (MB/sec)	23.27	18.96	20.06	20.76
Random read speed (IOPS/sec)	287.82	271.89	310.91	290.21
Random write speed (IOPS/sec)	316.99	262.28	339.32	306.20
Read/write cycles to first error	404	2,202	2,537	1,714
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	Prograde Digital Dual Slot Mobile Reader	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

This is another one I found on AliExpress after doing some more digging. I appreciated that they put at least a little bit of work in designing the artwork for both the packaging and the card, although the two designs seem to be completely different -- almost as if two different people were working on the designs, and they weren't coordinating with each other. It appears that this particular manufacturer has their own line of memory products -- including not only microSD cards, but also USB flash drives, SSDs (both internal and external), and RAM.

The package and card bear a strange combination of conflicting speed class marks, which would support my "the card and the packaging were designed by two different people" theory. Despite the disagreement, none of the three samples performed well enough to meet the threshold for the U3, V30, A1, and A2 marks. Perhaps they would have performed well enough to qualify for the U3 and V30 marks had they been tested under the right conditions; but given how poorly they performed on the random I/O tests, I doubt that it would have performed well enough for either the A1 or A2 marks even under the right conditions.

On the endurance front, it's looking like a mixed bag. As of this writing:

Sample #1 has completed 5,370 read/write cycles. Its first error was an I/O error during round 405.
Sample #2 managed to get past the 2,000 read/write cycle mark without issues; its first error was a data shift error during round 2,203. It has completed 5,196 read/write cycles total so far.
Sample #3's first error was a four-sector wide data shift error during round 2,538; it has survived 2,908 read/write cycles so far.

Last updated: 5/11/2024

QEEDNS 8GB

Advertised capacity: 8GB
Logical capacity: 8,053,063,680 bytes
Physical capacity: 8,053,063,680 bytes
Fake/skimpy flash: No
Protected area: 0 bytes
Speed class markings: Class 10, U1
CID data:
- Manufacturer ID: 0x00
- OEM ID: 0x0000
- Product name: 0x534d492020 (ASCII: SMI )
- Product revision: 0x00

Sample #	1	2	3	Average
Obtained from	AliExpress	AliExpress	AliExpress	N/A
Price paid	$2.57	$2.48	$2.48	$2.51
Manufacture date	Nov 2015	Not yet tested	Not yet tested	N/A
Serial number	`0x0x000007ff`	Not yet tested	Not yet tested	N/A
Sequential read speed (MB/sec)	17.94	Not yet tested	Not yet tested	17.94
Sequential write speed (MB/sec)	14.12	Not yet tested	Not yet tested	14.12
Random read speed (IOPS/sec)	1,170.16	Not yet tested	Not yet tested	1,170.16
Random write speed (IOPS/sec)	35.89	Not yet tested	Not yet tested	35.89
Read/write cycles to first error	6,111	Not yet tested	Not yet tested	6,111
Read/write cycles to complete failure	6,111	Not yet tested	Not yet tested	6,111
Total days to complete failure	79	Not yet tested	Not yet tested	79
Card reader used	SanDisk MobileMate	Not yet tested	Not yet tested	N/A
Package front		Not yet tested	Not yet tested	N/A
Package back		Not yet tested	Not yet tested	N/A
Card front		Not yet tested	Not yet tested	N/A
Card back		Not yet tested	Not yet tested	N/A

Discussion

QEEDNS (I'm just assuming it's spelled in all upper-case, because that's how it's printed on all of their cards) is another brand that popped up with some regularity when I was browsing AliExpress. This card arrived in a generic red packaging that seems to have been shared with a few other brands, such as Auotkn, Microdrive, the knockoff Lenovo cards, SanDian, and the knockoff Sony cards. This packaging did not have any brand name, manufacturer information, the size of the card, or class markings on it -- it was about as generic a package as you could get for an SD card. I think I only bought one of these because this was another case where I wanted to see if I could find fake and genuine cards from the same manufacturer.

This card had its manufacturer ID and OEM ID set to all zeroes, a trait which is shared by all of the brands I just listed -- with the exception of Microdrive (who had the manufacturer ID and OEM set to 0x6f and 0x0303, respectively) and the knockoff Sony 32GB card (who had the OEM ID set to 0x3432). I suspect that this was done intentionally because whoever manufactured these cards likely doesn't want their name associated with it. Bunnie (from Bunnie Studios) used the term "ghost shift" to describe runs of SD cards that are generally run off the books and using marginal material that would normally be disposed of -- and I suspect that these cards are likely a result of these ghost shifts.

Performance-wise, this card performed pretty poorly in comparison to many of the others I tested -- and yet, somehow it did well enough to qualify for the Class 10 and U1 marks that it carries. All speed measurements were well below average, with sequential read and random write speeds being more than one standard deviation below average. (Sequential write speeds were just barely less than one standard deviation below average.)

Sample #1 actually did fairly well on its endurance tests -- right up until it failed. One day, I decided to mount my USB hubs on the wall of my server closet, and a few days later, I decided to mount the AC adapters for these hubs by hammering cable tacks into the wall where the cords were going into it. I must have jarred something when I was doing this, because all of the card readers on that machine disconnected from the machine. I had to reset the entire USB controller to get them working again. I managed to get all of the other cards working again, but this card refused to come back to life -- it simply refused to respond to commands. I made several attempts (including with my trusty Realtek reader), but to no avail -- at which point I decided to simply declare the card dead.

Samples #2 and #3 are still in the package waiting to be tested.

Last updated: 3/14/2024

QEEDNS 512GB

Advertised capacity: 512GB
Logical capacity: 536,871,960,576 bytes
Physical capacity: 31,434,108,416 bytes
Fake/skimpy flash: Fake flash
Protected area: 0 bytes
Speed class markings: Class 10, U3
CID data:
- Manufacturer ID: 0x00
- OEM ID: 0x00
- Product name: 0x4150505344 (ASCII: APPSD)
- Product revision: 0x00

Sample #	1	2	3	Average
Obtained from	AliExpress	AliExpress	AliExpress	N/A
Price paid	$12.17	$14.01	$14.01	$13.40
Manufacture date	Sep 2021	Not yet tested	Not yet tested	N/A
Serial number	`0x12800000`	Not yet tested	Not yet tested	N/A
Sequential read speed (MB/sec)	12.48	Not yet tested	Not yet tested	12.48
Sequential write speed (MB/sec)	9.55	Not yet tested	Not yet tested	9.55
Random read speed (IOPS/sec)	472.40	Not yet tested	Not yet tested	472.40
Random write speed (IOPS/sec)	3.65	Not yet tested	Not yet tested	3.65
Read/write cycles to first error	447	Not yet tested	Not yet tested	447
Read/write cycles to complete failure	1,687	Not yet tested	Not yet tested	1,687
Total days to complete failure	101	Not yet tested	Not yet tested	101
Card reader used	Lexar LRWM05U-7000	Not yet tested	Not yet tested	N/A
Package front		Not yet tested	Not yet tested	N/A
Package back		Not yet tested	Not yet tested	N/A
Card front		Not yet tested	Not yet tested	N/A
Card back		Not yet tested	Not yet tested	N/A

Discussion

This is another card that I bought because I wanted to see if I could find genuine and fake flash in the same brand. And, it turns out that the answer is "Yes. Yes you can."

As with the 8GB card, this card had its manufacturer ID and OEM ID set to all zeroes -- and combined with the generic red packaging, it's pretty obvious that this seller is trying to hide who is manufacturing these cards for them.

Performance with this card was pretty abysmal -- even more abysmal with its smaller sibling. All performance metrics were more than one standard deviation below average. Sequential write speeds were just shy of what would be needed to qualify for Class 10 -- and it's possible that it would have made it over the 10MB/sec threshold had it been tested under proper conditions. However, it fell well short of what would be needed to qualify for the U3 marking.

Sample #1 started having issues during round 448; however, its issues started ramped up around round 1,534. It hobbled along for quite a while afterwards -- every so often (usually a few times a day towards the end), it would disconnect itself from the reader, and I would have to manually pull it and re-insert it into the reader to get it working again. It finally bit the dust during round 1,686 -- it disconnected itself from the reader, and re-inserting it would no longer solve the problem.

Here's what this sample's progression looked like:

Why did the number of bad sectors drop after round 1,647? Because it was experiencing enough errors to the point where my program could no longer automatically detect the device after I plugged it back in, so I had to restart the test from scratch. Afterwards, I added an option to the program to force it to resume from a given device.

Samples #2 and #3 are still in the package waiting to be tested.

Last updated: 3/24/2024

QWQ Extreme Pro 16GB

Obtained from: AliExpress
Price paid: $2.99
Advertised capacity: 16GB
Logical capacity: 16,106,127,360 bytes
Physical capacity: 8,478,740,480 bytes
Fake/skimpy flash: Fake flash
Protected area: 0 bytes
Speed class markings: Class 10, A1
CID data:
- Manufacturer ID: 0x00
- OEM ID: 0x0000
- Product name: 0x0000000000
- Product revision: 0x00

Sample #	1	2	3	4	5	6	Average
Manufacture date	Sep 2023	Sep 2023	Not yet tested	Not yet tested	Not yet tested	Not yet tested	N/A
Serial number	`0x00023786`	`0x0002377b`	Not yet tested	Not yet tested	Not yet tested	Not yet tested	N/A
Sequential read speed (MB/sec)	21.74	21.58	Not yet tested	Not yet tested	Not yet tested	Not yet tested	21.66
Sequential write speed (MB/sec)	11.17	10.50	Not yet tested	Not yet tested	Not yet tested	Not yet tested	10.84
Random read speed (IOPS/sec)	1,098.46	1,178.11	Not yet tested	Not yet tested	Not yet tested	Not yet tested	1,138.29
Random write speed (IOPS/sec)	0.82	0.82	Not yet tested	Not yet tested	Not yet tested	Not yet tested	0.82
Read/write cycles to first error	18	4	Not yet tested	Not yet tested	Not yet tested	Not yet tested	11
Read/write cycles to complete failure	Not yet determined	763	Not yet tested	Not yet tested	Not yet tested	Not yet tested	763
Total days to complete failure	Not yet determined	15	Not yet tested	Not yet tested	Not yet tested	Not yet tested	15
Card reader used	JJS CR-UTC4AC	JJS CR-UTC4AC	Not yet tested	Not yet tested	Not yet tested	Not yet tested	N/A
Package front			Not yet tested	Not yet tested	Not yet tested	Not yet tested	N/A
Package back			Not yet tested	Not yet tested	Not yet tested	Not yet tested	N/A
Card front			Not yet tested	Not yet tested	Not yet tested	Not yet tested	N/A
Card back			Not yet tested	Not yet tested	Not yet tested	Not yet tested	N/A

Discussion

In early 2024, AliExpress started running sales where items -- seemingly from a single seller -- were priced at either $1.99, $2.99, or $3.99, and you were allowed to purchase any combination of 10 items...I think per day? This one caught my attention for a couple of reasons: first, the bright orange color; and second, the fact that they offered it in a 618GB capacity -- it's rather odd for an SD card manufacturer to be offering a card in a size that isn't a power of 2. However, given that the prices on all of the sizes were practically identical, the 618GB card is almost certainly fake, and hence I didn't buy any of them (yet).

This particular brand also has two different card designs: one whose cards had a primarily orange and white design, and one whose cards had a primarily blue and black design. When I ordered these, I must have thought that there was a significant difference between the two -- like maybe only one of them had the "Extreme Pro" label on it -- but after receiving them and looking at them more closely, I can't see a difference between them. They both appear to have the "Extreme Pro" label -- and thus, I'm going to lump them both under this section.

I was surprised that this card turned out to be fake -- usually smaller capacity cards like this are genuine. But, I suppose there are sellers who will skimp on just about anything to make a buck.

I've only tested two of these cards so far, but the performance on them so far has been...terrible. All performance metrics were below average. And, except for the random read speeds, all performance metrics were more than one standard deviation below average. Surprisingly, however, this card had the best sequential read speeds of any card in the "fake flash" category so far -- if only that meant something.

This card bears the Class 10 and A1 marks; and while performance was good enough to qualify for the Class 10 mark -- although just barely -- it missed the mark on both random read and random write speeds that would be needed for the A1 mark. And while I'll throw in my standard disclaimer -- that perhaps this card would have done better had it been tested under the proper conditions -- I highly doubt it, especially with random write speeds as terrible as they were.

Endurance tests for sample #1 is still ongoing; however, it only managed to go for 18 read/write cycles before it experienced its first error. It has survived 4,475 read/write cycles in total so far.

Sample #2 only managed to go for 4 read/write cycles before it encountered its first error. It continued to experience errors every few rounds -- affecting about 1,024 sectors at a time -- until round 763, when suddenly over half of the sectors started reading back as all 0xff's. Here's what this sample's progression looked like:

Samples #3-#6 are still in the package waiting to be tested.

Last updated: 5/11/2024

Reletech 32GB

Obtained from: AliExpress
Price paid: $2.99
Advertised capacity: 32GB
Logical capacity: 31,266,439,168 bytes
Physical capacity: 31,266,439,168 bytes
Fake/skimpy flash: Skimpy (2.29% skimp)
Protected area: 83,886,080 bytes (inaccessible)
Speed class markings: Class 10, U3, A1
CID data:
- Manufacturer ID: 0xfe
- OEM ID: 0x3432 (ASCII: 42)
- Product name: 0x5344313647 (ASCII: SD16G)
- Product revision: 0x20

Sample #	1	2	3	Average
Manufacture date	Jun 2023	May 2023	Jun 2023	N/A
Serial number	`0x00001fe3`	`0x000032f1`	`0x00002e91`	N/A
Sequential read speed (MB/sec)	86.22	88.32	20.82	65.12
Sequential write speed (MB/sec)	19.33	16.43	12.94	16.23
Random read speed (IOPS/sec)	1,564.81	1,441.72	1,225.64	1,410.72
Random write speed (IOPS/sec)	289.82	272.14	260.35	274.10
Read/write cycles to first error	1,522	Not yet determined	Not yet determined	1,522
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	JJS CR-UTC4AC	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

In early 2024, AliExpress started running sales where items -- seemingly from a single seller -- were priced at either $1.99, $2.99, or $3.99, and you were allowed to purchase any combination of 3-10 items...I think per day? This caught my attention, so I looked through and found a few brands of microSD cards that I hadn't seen before, including this one.

The product packaging was a little unusual, in that it had a mixture of English and French...and an office address in Germany. This leads me to believe that they wanted buyers to think that this was a North American or European brand -- but then someone ruined the illusion by slapping a sticker on the back that says "Shenzhen Guanlin International Trade Co.,Ltd". On the bright side, at least this particular card isn't fake flash. They do have some bigger sizes, and the prices on those scale up with size, so I'm guessing that those aren't fake flash either. Who knows, I might have to try those out sometime.

I've only tested one sample so far, but performance was just "meh". Sequential read speeds were a little above average, while sequential write speeds were pretty well below average. Random read and write speeds were just average. While this was good enough to qualify for the Class 10 mark, it fell well short of the 30MB/sec write speeds required for the U3 mark, and well short of the 500 random write operations per second required for the A1 mark. Perhaps this card would have done better had it been tested under proper conditions -- but somehow I doubt it.

Endurance tests for all three samples are still ongoing:

Sample #1's first error was a four-sector wide data shift error during round 1,523. It has endured 1,829 read/write cycles in total so far.
Samples #2 and #3 have not yet hit the 2,000 read/write cycle mark; they are currently expected to reach this point sometime in September 2024.

Last updated: 5/11/2024

Samsung EVO Plus 32GB

Obtained from: Amazon
Price paid: $11.99
Advertised capacity: 32GB
Logical capacity: 32,010,928,128 bytes
Physical capacity: 32,010,928,128 bytes
Fake/skimpy flash: No
Protected area: 83,886,080 bytes (inaccessible)
Speed class markings: Class 10, U1
CID data:
- Manufacturer ID: 0x1b*
- OEM ID: 0x534d (ASCII: SM)*
- Product name: 0x4542315154 (ASCII: EB1QT)
- Product revision: 0x30

* This manufacturer ID/OEM ID is well known to be associated with Samsung.

Sample #	1	2	3	Average
Price paid	$11.99	$11.80	$11.80	$11.86
Manufacture date	Feb 2020	Feb 2020	Feb 2020	N/A
Serial number	`0x1d4e67b6`	`0x34146748`	`0x341d67e5`	N/A
Sequential read speed (MB/sec)	91.21	90.69	90.21	90.70
Sequential write speed (MB/sec)	28.48	28.23	27.08	27.93
Random read speed (IOPS/sec)	1,672.43	1,677.64	1,683.06	1,677.71
Random write speed (IOPS/sec)	352.26	424.28	409.26	395.27
Read/write cycles to first error	Not yet determined	Not yet determined	1,415	1,415
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	JJS CR-UTC4AC	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

Samsung is a pretty well known name in the electronics industry, and flash memory is no exception. I purchased this one because I wanted to have a few legitimately obtained, name brand cards in my collection to compare the AliExpress samples to. I would like to have a couple more samples to test, but these cards are a bit more expensive than many of the others in my collection and it'll have to wait until I can spare the money to buy some more.

One thing of consequence that I'll note: Samsung is one of two mainstream brands (of the ones I evaluated) whose flash was neither fake nor skimpy (Lexar being the other). Both of the Samsung cards in my collection currently are 32GB cards, and both offered at least 32 billion bytes of user space. Many of the other name brands -- including Kioxia, SanDisk, and Kingston -- provided cards that were all skimpy, so I was pleasantly surprised to see that Samsung was not.

Performance-wise, I was actually a bit disappointed. Sequential read speeds were well above average, but all of the other scores were just...average. For such a well-recognized brand, I would have expected better. It did, however, perform well enough to qualify for the Class 10 and U1 marks that it carried. I will note, however, that Samsung seems to be phasing out this particular version of the EVO Plus. The new version (of which the Samsung EVO Plus 64GB is a member) seems to have a more simplistic design and sports faster speeds.

All three samples are currently undergoing endurance testing:

Sample #1 has done pretty well. As of this writing, it has gone 5,238 read/write cycles and has not experienced any errors.
Sample #2 has not yet hit the 2,000 read/write cycle mark; it is currently estimated to reach this point in late May 2024.
Sample #3's first error was a four-sector wide data shift error during round 1,416; it has survived 1,810 read/write cycles total so far.

Last updated: 5/11/2024

Samsung EVO Plus 64GB

Obtained from: AliExpress
Price paid: $3.99
Advertised capacity: 64GB
Logical capacity: 64,088,965,120 bytes
Physical capacity: 64,088,965,120 bytes
Fake/skimpy flash: No
Protected area: 134,217,728 bytes (inaccessible)
Speed class markings: Class 10*, U1, V10, A1
CID data:
- Manufacturer ID: 0x1b**
- OEM ID: 0x534d (ASCII: SM)**
- Product name: 0x4543315335 (ASCII: EC1S5)
- Product revision: 0x30

* The Class 10 mark appears on the package, but does not appear on the card itself.

** This manufacturer ID/OEM ID combination is pretty well known to be associated with Samsung.

Sample #	1	2	3	Average
Manufacture date	Jul 2023	Jul 2023	Jul 2023	N/A
Serial number	`0x09a55f26`	`0x09d05fcd`	`0x09ad5f7a`	N/A
Sequential read speed (MB/sec)	150.44	151.46	147.92	149.94
Sequential write speed (MB/sec)	27.20	27.05	27.06	27.10
Random read speed (MB/sec)	2,913.70	2,917.73	2,918.01	2,916.48
Random write speed (MB/sec)	446.07	486.34	469.78	467.40
Read/write cycles to first error	Not yet determined	724	0	0
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	JJS CR-UTC4AC	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

I'm not 100% sure why I decided to buy these. I think that it might have been because of the sale that AliExpress was running on these, and I figured that it might make a good substitute for having three of the EVO Plus 32GB's (before I decided to buy two more of them). Regardless, it looks like Samsung has phased out the particular version of the EVO Plus that I had previously purchased in favor of this version.

With a skimp rating of -0.14%, Samsung continued their reputation here of being one of the only name-brands that has not skimped on storage space.

The package advertises that this card gets transfer speeds of "up to 130MB/s". Of course, it doesn't specify whether that's referring to read speeds or write speeds, but I think it's pretty obvious (to me, at least) that it's referring to read speeds. It managed to meet that expectation -- and even go a little bit beyond it. Sample #2's sequential read scores were the highest of the three, scoring just over two standard deviations above average, while the other two came just shy of two standard deviations above average. Random read scores were more than one standard deviation above average, and random write scores were above average. Sequential write scores, however, were slightly below average. These metrics are good enough for the U1 and V10 marks that it carries -- and the Class 10 mark on the package -- but not quite good enough for the A1 mark (as that requires a random write speed of at least 500 writes per second). Perhaps they would have met the mark had they been tested under the right conditions. I'm curious to see how the other two samples will perform.

Endurance tests for all three cards are still ongoing:

Sample #1 has not yet reached the 2,000 read/write cycle mark; it is expected to reach this point in July 2024.
Sample #2's first error was a four-sector wide data shift error during round 725; it has survived 898 read/write cycles so far.
Sample #3 experienced a 6,400-sector wide data verification error during its very first round of endurance testing. It has survived just 875 read/write cycles so far.

Last updated: 5/11/2024

Samsung PRO Endurance 32GB

Obtained from: Amazon
Price paid: $6.99
Advertised capacity: 32GB
Logical capacity: 32,044,482,560 bytes
Physical capacity: 32,044,482,560 bytes
Fake/skimpy flash: No
Protected area: 83,886,080 bytes (inaccessible)
Speed class markings: Class 10*, U1, V10
CID data:
- Manufacturer ID: 0x1b*
- OEM ID: 0x534d (ASCII: SM)*
- Product name: 0x4a42315135 (ASCII: JB1Q5)
- Product revision: 0x30

* This manufacturer ID/OEM ID is pretty well known to be associated with Samsung.

Sample #	1	2	3	Average
Manufacture date	Aug 2023	Jan 2024	Dec 2023	N/A
Serial number	`0x418e5fef`	`0x656057b5`	`0xc4b65783`	N/A
Sequential read speed (MB/sec)	89.96	83.23	83.01	85.40
Sequential write speed (MB/sec)	28.70	28.31	28.86	28.62
Random read speed (IOPS/sec)	4,365.76	2,881.03	2,784.60	3,343.80
Random write speed (IOPS/sec)	450.28	527.10	526.92	501.43
Read/write cycles to first error	3,687	Not yet determined	Not yet determined	3,687
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	SmartQ Single	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

This is one I purchased because -- I think -- I wanted to see how "high endurance" cards perform compared to their contemporary (low endurance?) cousins.

As I stated above, Samsung is a pretty well-known player in the electronics industry, and their SD cards are no exception. And, as with the Samsung EVO Plus, it's nice to see that Samsung didn't skimp on storage -- in fact, this one is slightly larger than the EVO Plus.

Performance-wise, this card did well on read tests, but I was a little disappointed by write performance. All three samples got above average sequential read and random write speeds, and scored more than one standard deviation above average on random read tests, but got below average sequential write speeds. It did well enough to qualify for all of the marks that appeared on it (nearly by a factor of 3), but when compared to the other name-brand cards I tested, it did worse on the sequential write test, and only average on the random write test.

All three cards are still undergoing endurance testing:

Sample #1 has survived 8,488 read/write cycles so far. It experienced data verification failures earlier on, but I was able to chalk those errors up to issues with my code. The first errors that I wasn't able to attribute to code issues happened during round 3,688.
Samples #2 and #3 have not yet reached the 2,000 read/write cycle mark; they're currently expected to reach that point sometime in late May 2024.

So just how long should this card last? If we look at Samsung's product page for this card, they have a footnote where they list the rated endurance 17,520 hours of Full HD video at 26Mb/sec, which translates to about 205TB, or 6,397 read/write cycles. Sample #1 only made it a little over halfway there before it experienced its first error -- which admittedly makes me a little disappointed. Hopefully the other two will fare better.

Last updated: 5/11/2024

SanDian Extreme PRO 128GB

Obtained from: AliExpress
Price paid: $5.22
Advertised capacity: 128GB
Logical capacity: 134,218,776,576 bytes
Fake/skimpy flash: Fake flash
Protected area: 0 bytes
Speed class markings: U3, V30, A2
CID data:
- Manufacturer ID: 0x00
- OEM ID: 0x0000
- Product name: 0x4150505344 (ASCII: APPSD)
- Product revision: 0x00

Card #	1	2	3	Average
Physical capacity	32,193,277,440 bytes	32,054,865,408 bytes	33,894,067,712 bytes	32,714,070,186 bytes
Manufacture date	Aug 2017	Aug 2017	Aug 2017	N/A
Serial number	`0x12800005`	`0x12800000`	`0x12800002`	N/A
Sequential read speed (MB/sec)	16.73	15.18	16.01	15.97
Sequential write speed (MB/sec)	8.92	7.09	10.73	8.91
Random read speed (IOPS/sec)	490.39	1,200.13	1,107.44	932.65
Random write speed (IOPS/sec)	0.49	0.38	0.36	0.41
Read/write cycles to first error	101	519	439	310
Read/write cycles to complete failure	869	618	981	823
Total days to complete failure	83	46	91	73
Card reader used	JJS CR-UTC4AC	JJS CR-UTC4AC	Togconn TOG-SD-CR	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

SanDian is a name that came up fairly frequently in my AliExpress searches, and it was pretty apparent that they were trying to rip off SanDisk -- from the product lineup names ("Ultra", "Extreme", "Extreme PRO"), to the similar visual design (with the red/black stripes), to the logo (which copies the styled "nD" from SanDisk's logo). Seeing as how they had several options to choose from, I decided to order a few of each one -- in the 128GB and 1TB denominations. However -- and I'm going to bury the lead here -- they didn't hold a candle to SanDisk (at least so far).

Initially I was going to lump them into the "off-brand" category; however, given just how closely they're copying SanDisk's design, I decided to re-categorize them as knockoffs.

I found it interesting that these cards came in a package that appeared to be for a USB cable rather than the normal clamshell packaging that most SD cards come in.

This is another instance of a seller who set the manufacturer ID and OEM ID to all zeroes to mask their identity and/or the identity of whoever manufactured these cards for them. If the remainder of the CID data is to be believed, then it would mean that these cards were over 6 years old by the time they made it to me. I did manage to find a SanDian store on AliExpress, but their front page made it appear that they were selling women's clothing -- and to boot, they had no actual products listed at the time I looked. This might mean that the SanDian name is being retired (and/or the seller has gone out of business) and that sellers who purchased their cards are simply trying to offload their remaining inventory.

Another thing I found interesting was that physical capacity differed between the three samples. Honestly, I'm at a loss to explain this.

Performance was pretty abysmal, with all metrics being well below average. Even when compared to other fake flash cards in my collection, scores were below average -- with the exception of sample #1's sequential read speed (which was only slightly above average) and sample #2's random read speed (which was just shy of one standard deviation above average). Performance was not good enough to qualify for any of the speed class markings this card carried. I'll add my standard "perhaps this card would have performed better if it had been tested under proper conditions" disclaimer, but I highly doubt it would have done much better. Honestly, I would have expected more from a card labeled "Extreme PRO". Much more. But then again, this is a knockoff brand.

On the endurance front, things are not looking good here either. None of the three samples made it 2,000 read/write cycles -- or even 1,000 read/write cycles -- before encountering errors.

Sample #1's first error was a series of bit flip errors affecting two sectors during round 102. It made it 869 read/write cycles before it decided to stop responding to commands. By this point, it had been struggling to stay alive: over 40% of the sectors on the device had been flagged as "bad", and it went through a couple different phases: one where it disconnected itself from the reader multiple times a day (and had to be unplugged and plugged back in), and one where it would experience long strings of I/O errors before just deciding to work normally again. Finally, though, during round 870, it disconnected itself from the reader and refused to start working again when reconnected -- at that point, I decided to declare it "dead".

Here's what Sample #1's progression looked like:

Sample #2's first error was a series of bit flip errors affecting about 3,400 sectors during round 521. The problem became progressively worse over the following rounds of testing, reaching the point where about 4.27% of the sectors on the device had experienced errors. It finally stopped responding to commands during round 619. Here's the graph of what this progression looked like:

Sample #3's first error was a series of bit flip errors during round 440. Like the other two, it slowly deteriorated to the point where over half the sectors on the device had been flagged as "bad". Here's what the progression for this sample looked like:

My overall assessment of these cards? Don't buy them. They perform horribly, not a single one made it even halfway to my 2,000 read/write cycle goalpost, and they're fake flash to boot. With a little bit of digging, you can find cheaper name-brand cards that are more reliable, have greater capacity, and have way better performance. (Case in point: the Samsung EVO Plus 64GB.)

Last updated: 4/18/2024

SanDian Extreme PRO 1TB

Obtained from: AliExpress
Price paid: $6.62
Advertised capacity: 1TB
Logical capacity: 1,072,694,296,576 bytes
Physical capacity: 29,943,033,344 bytes
Fake/skimpy flash: Fake flash
Protected area: 0 bytes
Speed class markings: U3, V30, A2
CID data:
- Manufacturer ID: 0x00
- OEM ID: 0x0000
- Product name: 0x4150505344 (ASCII: APPSD)
- Product revision: 0x00

Card #	1	2	3	Average
Manufacture date	Apr 2014	Apr 2014	Apr 2014	N/A
Serial number	`0x12800006`	`0x12800007`	`0x12800000`	N/A
Sequential read speed (MB/sec)	16.71	16.78	16.62	16.70
Sequential write speed (MB/sec)	15.33	14.33	10.27	13.31
Random read speed (IOPS/sec)	415.03	1,123.40	1,089.49	875.97
Random write speed (IOPS/sec)	9.94	0.43	0.42	3.60
Read/write cycles to first error	41	Not yet determined	23	32
Read/write cycles to complete failure	1,283	Not yet determined	Not yet determined	1,283
Total days to complete failure	98	Not yet determined	Not yet determined	98
Card reader used	JJS CR-UTC4AC	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

There's not much to say about this card that is going to be different than the 128GB version. Like its smaller sibling, this card was disappointing at best.

Performance metrics were well below average and were only marginally better than the 128GB version -- and, like the 128GB version, were not good enough to merit any of the performance marks that it carried.

Like many of the low-quality cards I've tested, sample #1 started experiencing errors after only a few read/write cycles, and the number of errors only increased as time went on. It was declared "dead" after 50% of the sectors on the device had been flagged as "bad". Here's what the graph of this card's progression looked like:

Sample #2's has not yet reached the 2,000 read/write cycle mark; it is currently expected to reach this point in November 2024.

Sample #3's first error was a 32-sector wide data loss error during round 24; it has survived 128 read/write cycles in total so far.

Last updated: 5/11/2024

SanDisk Extreme 32GB

Advertised capacity: 32GB
Protected area: 83,886,080 bytes
Fake/skimpy flash: Skimpy (0.27% skimp)
Speed class markings: U3, V30, A1
CID data:
- Manufacturer ID: 0x03*
- OEM ID: 0x5344 (ASCII: SD)*
- Product revision: 0x80

* This manufacturer ID/OEM ID combination are pretty well known to be associated with SanDisk.

Card #	1	2	3	Average
Obtained from	Amazon	AliExpress	AliExpress	N/A
Price paid	$10.49	$9.70	$9.70	$9.96
Logical capacity	31,914,983,424 bytes	31,902,400,512 bytes	31,902,400,512 bytes	31,906,594,816 bytes
Physical capacity	31,914,983,424 bytes	31,902,400,512 bytes	31,902,400,512 bytes	31,906,594,816 bytes
Fake/skimpy flash	Skimpy (0.27% skimp)	Skimpy (0.30% skimp)	Skimpy (0.30% skimp)	N/A
Adjusted skimp	0.0035%	0.04%	0.04%	0.03%
Product name	`0x534d333247` (ASCII: `SM32G`)	`0x534e333247` (ASCII: `SN32G`)	`0x534e333247` (ASCII: `SN32G`)	N/A
Manufacture date	Apr 2020	Sep 2023	Sep 2023	N/A
Serial number	`0x5340b8ea`	`0xfb233772`	`0xfb233938`	N/A
Sequential read speed (MB/sec)	76.73	126.87	151.46	118.35
Sequential write speed (MB/sec)	46.14	49.25	50.14	48.51
Random read speed (IOPS/sec)	2,097.00	2,668.37	2,606.13	2,457.17
Random write speed (IOPS/sec)	339.00	452.93	449.49	413.81
Read/write cycles to first error	5,215	74	70	1,786
Read/write cycles to complete failure	5,215	Not yet determined	Not yet determined	5,215
Total days to complete failure	160	Not yet determined	Not yet determined	160
Card reader used	JJS CR-UTC4AC	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

Ok, it's time to move on to one of my favorite brands.

Yes, I'm biased in favor of SanDisk. I've been using their microSD cards in some of my other projects for years (specifically, the SanDisk Ultra, usually the 16GB size) and have found them to be pretty rock-solid. That said, I wanted to try to be objective here. Additionally, before starting this project, my only experience was with the Ultras -- I hadn't used the Extremes or the Extreme PROs.

I'll note here that I ordered these cards in different batches. The first batch came from Amazon, and consisted of one of each of the SanDisk Extreme and SanDisk Extreme PRO, in both the 32GB and 64GB sizes. The second batch came from AliExpress, and consisted of two each of the SanDisk Extreme and SanDisk Extreme PRO, in the 32GB size. Why order different sizes? Because SanDisk advertises different maximum speeds between the two. This version is supposed to get up to 100MB/sec read speeds, and 60MB/sec write speeds. Additionally, the 64GB model had the A2 mark, while the 32GB model had the A1 mark instead.

I think I got slightly different versions from the two sources: the version I got from Amazon has a product name of SM32G, while the two I got from AliExpress have a product name of SN32G. There's also a noticeable difference in performance between the two: sample #1 only got about 3/4 of the way to the 100MB/sec mark, but samples #2 and #3 went well past it. (How did they do it? SanDisk apparently has some tricks up their sleeve -- see the discussion on the SanDisk Extreme PRO 64GB for more info.)

How does this stack up against the other cards I tested? All three samples got above average scores in all performance metrics. Samples #2 and #3 got sequential read and sequential write scores that were more than one standard deviation above average. Sample #3's sequential read speeds were actually more than two standard deviations above average. Sample #2 also got a random read speed that was more than one standard deviation above average.

This card carries the U3, V30, and A1 markings on it. The results I got are good enough to satisfy the requirements of the U3 and V30 marks; however, the A1 mark requires a random write speed of at least 500 IOPS/sec, and none of these samples met that requirement. Again, I'll give my standard disclaimer of "perhaps this card would have done better had it been tested under proper conditions". The two AliExpress samples were close enough to this mark that this could actually be true.

Endurance tests for two of the three cards are still ongoing:

Sample #1 was doing great until the circuit breaker -- to which the host machine was attached -- tripped. After restoring power, all of the other cards attached to this machine resumed their testing just fine; however, this one decided that it was done. Admittedly, this made me a little sad, as this particular card had not experienced any errors up until that point. As I mentioned with the SanDisk Ultra 32GB's, embeddedTS once did similar stress testing of some SanDisk cards and noted that they tend to be sensitive to brownouts -- and with the way some of these SanDisk cards are going, I'm forced to agree.
Sample #2 experienced a data shift error after only 74 read/write cycles. It seems like it's been particularly susceptible to data shift errors -- it experienced eight different data shift errors over the first 1,031 read/write cycles. It has survived 2,598 read/write cycles in total so far.
Sample #3 experienced a data shift error after just 70 read/write cycles. It also seems like it's been susceptible to data shift errors, having experienced five different data shift errors over the first 1,083 read/write cycles. It has survived 2,539 read/write cycles in total so far.

Last updated: 5/11/2024

SanDisk Extreme 64GB

Advertised capacity: 64GB
Fake/skimpy flash: Skimpy (0.21% skimp)
Protected area: 134,217,728 bytes
Speed class markings: U3, V30, A2
CID data:
- Manufacturer ID: 0x03*
- OEM ID: 0x5344 (ASCII: SD)*
- Product name: 0x534e363447 (ASCII: SN64G)

* This manufacturer ID/OEM ID combination is pretty well known to be associated with SanDisk.

Sample #	1	2	3	Average
Obtained from	Amazon	AliExpress	AliExpress	N/A
Price paid	$10.43	$9.60	$9.60	$9.88
Logical capacity	63,864,569,856 bytes	63,887,638,528 bytes	63,887,638,528 bytes	63,879,948,970 bytes
Physical capacity	63,864,569,856 bytes	63,887,638,528 bytes	63,887,638,528 bytes	63,879,948,970 bytes
Fake/skimpy flash	Skimpy (0.21% skimp)	Skimpy (0.18% skimp)	Skimpy (0.18% skimp)	Skimpy (0.19% skimp)
Adjusted skimp	0.0019%	-0.03%	-0.03%	-0.019%
Product revision	`0x86`	`0x85`	`0x85`	N/A
Manufacture date	Sep 2023	Sep 2023	Sep 2023	N/A
Serial number	`0xd84929ad`	`0xfea61ca2`	`0xfea61c88`	N/A
Sequential read speed (MB/sec)	85.94	165.70	159.05	136.90
Sequential write speed (MB/sec)	51.68	69.00	74.29	64.99
Random read speed (IOPS/sec)	3,334.23	2,910.07	2,795.22	3,013.17
Random write speed (IOPS/sec)	293.81	640.39	1,154.36	696.19
Read/write cycles to first error	1,269	Not yet determined	Not yet determined	1,269
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	SanDisk MobileMate	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

Continuing my (hopefully objective) evaluation of SanDisk cards, I purchased both the 32GB and the 64GB versions of this card. As I alluded to earlier, I purchased the 64GB version for a very particular reason.

SanDisk has a "gimmick" with some of their cards: they're UHS-I cards, but SanDisk advertises speeds that are beyond what should be possible under the UHS-I spec. Under UHS-I, the maximum clock speed for an SD card is 208MHz, and SD cards have four lines for transferring data -- which means that the maximum possible speed should be 832Mbit/sec, or 104MB/sec. However, this card advertises that it can get read speeds of up 170MB/sec and write speeds of up to 80MB/sec. I don't know exactly how they do this, but if you look closely at the package, there's an asterisk: it requires a "compatible device capable of reaching such speeds". There's also a note on the front of the package that says "Compatible with SanDisk Professional PRO-READER SD and microSD to achieve stated read speeds". I suspect that these card readers have some mechanism to detect whether the card is one that should support these higher speeds; if they do, I suspect that the reader simply overclocks the card to get those speeds.

I don't have one of the SanDisk Professional PRO-READER SD or microSD readers; however, I do have several SanDisk MobileMate microSD readers -- and on the package, it says -- quite prominently -- "Enables SanDisk enhanced UHS-I microSD card speeds". This should mean that I should be able to use this reader with this card and get the speeds they advertise (or close to it), right? Well...nope. Actual read/write speeds only got about halfway to the maximum stated on the package.

Compared to the other cards in my collection, sequential read and sequential write speeds were above average, with sequential write speeds being more than one standard deviation above average. Random read speeds were more than one standard deviation above average as well; however, random write speeds were slightly below average. Compared to the other name-brand cards that I tested, sequential read and random write speeds were below average. While this is good enough for the U3 and V30 marks that it carries, the A2 mark requires random read speeds of 4,000 IOPS/sec and random write speeds of 2,000 IOPS/sec -- and this card fell well short of that.

Side note: no card I've tested so far has met the performance thresholds for the A2 mark. To reach the speeds required for the A2 mark requires some pretty advanced features of the SD spec, which probably requires hardware beyond what I have. However, this card's random write speeds weren't even good enough for the A1 mark -- and seeing as how I have other cards in my collection that did meet the threshold for the A1 mark, I doubt that it would have performed well enough for the A2 mark even if it had been tested under the right conditions.

Endurance tests for all three cards are still ongoing:

Sample #1 suffered several data shift errors starting in round 1,270. It has survived 4,441 read/write cycles in total. While disappointing that this card couldn't make it past the 2,000 read/write cycle mark without errors, the number of sectors affected so far has been fairly small (only 114).
Sample #2 has survived 3,384 read/write cycles so far and has not yet experienced any issues.
Sample #3 has not yet reached the 2,000 read/write cycle mark. It is currently expected to reach this point in June 2024.

Last updated: 5/11/2024

SanDisk Extreme PRO 32GB

Advertised capacity: 32GB
Logical capacity: 31,914,983,424 bytes
Physical capacity: 31,914,983,424 bytes
Fake/skimpy flash: Skimpy (0.27% skimp)
Protected area: 83,886,080 bytes
Adjusted skimp: 0.0035%
Speed class markings: U3, V30, A1
CID data:
- Manufacturer ID: 0x03*
- OEM ID: 0x5344 (ASCII: SD)*
- Product name: 0x5350333247 (ASCII: SP32G)
- Product revision: 0x80

* This manufacturer ID/OEM ID combination is pretty well known to be associated with SanDisk.

Card #	1	2	3	Average
Obtained from	Amazon	AliExpress	AliExpress	N/A
Price paid	$12.63	$8.55	$8.55	$9.91
Serial number	`0x7a879790`	`0x8958014d`	`0x87b80078`	N/A
Manufacture date	Jun 2023	Mar 2023	Mar 2023	N/A
Sequential read speed (MB/sec)	88.36	87.23	88.05	87.88
Sequential write speed (MB/sec)	54.35	53.93	53.69	53.99
Random read speed (IOPS/sec)	1,867.13	1,882.37	1,830.30	1,859.93
Random write speed (IOPS/sec)	424.56	442.15	430.39	432.37
Read/write cycles to first error	5,188	117	155	1,820
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	JJS CR-UTC4AC	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

In addition to the SanDisk Extremes, I wanted to test out some SanDisk Extreme PROs as well to see if there was any significant difference between the two.

Like the SanDisk Extreme 32GB, this card doesn't make any extravagant speed claims -- just "speeds" (it doesn't specifically call out read or write speeds) of up to 100MB/sec. However, unlike the Extreme 32GB, I did not receive different models from Amazon vs. AliExpress -- both versions had their product name set to SP32G. All performance metrics for all three samples were above average, with sequential write speeds -- again, on all three samples -- being more than one standard deviation above average. Sequential read/write speeds and random write speeds were slightly better than SM32G, although random read speeds were worse. Compared to the SN32Gs, however, read speeds (both sequential and random) were considerably worse, and write speeds (both sequential and random) were on par. Compared to the other name-brand cards that I tested, sequential read speeds were slightly below average, but all other metrics slightly better. Performance was good enough to merit the U3 and V30 marks; however, the A1 mark requires a write performance of at least 500 IOPS/sec, and all three samples fell a little short here. This is going to be another case where I'll throw in my standard disclaimer: these cards may have done better here if they had been tested under proper conditions. They came close enough to the 500 IOPS/sec mark that this might actually be true.

Endurance tests for all three cards are still ongoing:

Sample #1 did make it past the 2,000 read/write cycle mark without experiencing any errors; its first error was an eight-sector wide data shift error during round 5,189. It has survived 5,243 read/write cycles in total so far.
Sample #2 only survived 117 read/write cycles before experiencing a data shift error. It has survived 3,635 read/write cycles so far.
Sample #3 only survived 155 read/write cycles before also experiencing a data shift error. It has survived 3,634 read/write cycles so far.

Last updated: 5/11/2024

SanDisk Extreme PRO 64GB

Advertised capacity: 64GB
Logical capacity: 63,864,569,856 bytes
Physical capacity: 63,864,569,856 bytes
Fake/skimpy flash: Skimpy (0.21% skimp)
Protected area: 134,217,728 bytes
Adjusted skimp: 0.0019%
Speed class markings: U3, V30, A2
CID data:
- Manufacturer ID: 0x03*
- OEM ID: 0x5344 (ASCII: SD)*
- Product name: 0x5352363447 (ASCII: SR64G)
- Product revision: 0x86

* This manufacturer ID/OEM ID combination is pretty well known to be associated with SanDisk.

Sample #	1	2	3	Average
Obtained from	Amazon	AliExpress	AliExpress	N/A
Price paid	$12.99	$10.63	$10.63	$11.42
Manufacture date	Sep 2023	Oct 2023	Oct 2023	N/A
Serial number	`0xa5f89e85`	`0xd1e25004`	`0xd1024e86`	N/A
Sequential read speed (MB/sec)	86.43	87.19	84.86	86.16
Sequential write speed (MB/sec)	60.34	52.56	62.71	58.54
Random read speed (IOPS/sec)	2,023.75	1,755.97	1,834.40	1,871.37
Random write speed (IOPS/sec)	349.67	298.88	394.89	347.81
Read/write cycles to first error	2,034	Not yet determined	Not yet determined	2,034
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	JJS CR-UTC4AC	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Discussion

As with the SanDisk Extreme 64GB, this card makes some pretty extravagant performance claims -- which is why I got it. This one's claims are even more extravagant than the SanDisk Extreme 64GB -- it claims you can get read speeds of up to 200MB/sec and write speeds of up to 90MB/sec.

Before I talk about performance, I want to talk a little bit about the card reader I used for this card: the JJS CR-UTC4AC. JJS doesn't specify which chip they use, but some deduction can tell us which one they probably used. The reader gives its vendor ID as 0x05e3 and its product ID as 0x0764. Vendor ID 0x05e3 belongs to Genesys Logic, Inc. The Linux USB project maintains a list of known vendor ID/product ID combinations; however, this list doesn't have an entry for product ID 0x0764. We're not finished yet, however.

If we go to Genesys Logic's website and look at the list of the card reader controllers that they offer, we see that they offer -- as of this writing -- 20 different options:

A screenshot from Genesys Logic's website showing a list of card reader controllers they offer.

We can filter out some of these options based on what we know:

The last two options -- the GL9750 and the GL9755 are PCI Express (not USB), so we can knock them off the list.
The three options directly above that -- the GL835, GL835T, and GL892S -- are only USB 2.0, so we can knock those off the list.
The GL3227E and GL3224E are eMMC controllers, so we can knock those off the list.
The GL3232, GL3232S, GL3213L, and GL3233T are all single-LUN readers, so we can knock them off the list.
UHS-II was added in version 4 of the SD card specification. The GL3230, GL3231, GL3223, GL3224, GL3224L, and GL3235 only support version 3 of the SD card spec, so we can knock those off the list.
If we pull up the product page for the GL3239, it only mentions support for version 1.0, 1.1, 2.0, and 3.0 of the SD specification -- no mention of version 4.0, which means we can knock this one off the list as well.

This leaves us with only two options: the GL3230S and the GL3231S. The GL3230S is a controller that supports a wide array of memory card types: not just SD/MMC, but also CompactFlash and Memory Stick (and its many derivatives). The GL3231S, on the other hand, only supports SD/MMC (and their derivatives). In addition, the GL3230S is a 4-LUN chip, while the GL3230S is a 2-LUN chip. It's been my experience that multi-LUN card readers generally present all of their LUNs to the host as soon as it's plugged in (regardless of whether or not there's a card plugged into it) -- and these readers only present two to my system. (Additionally, the GL3230S is probably more expensive than the GL3231S -- and JJS probably wouldn't have paid extra for those extra LUNs unless they planned to actually use them.)

Based on this, I think it's probably safe to say that these readers use the GL3231S.

Why all the detective work? Well...if you look at the product page for this reader, there's a statement that stands out to me. It's even in the very first paragraph on the page:

Screenshot from Genesys Logic's website, from the product page for the GL3231S. The statement "GL3231S also supports SANDISK EXTREME 160MB/s microSD UHS-I CARD" is highlighted.

Now...you could make the argument that this statement is only saying that it supports the card itself -- not the enhanced transfer rates that this card offers. But if that's the case, why bother making that statement at all? Without the enhanced transfer rates, the SanDisk Extreme cards are just regular SD cards -- and they don't bother to call out any other SD cards by name. To me, this means that this reader should support the enhanced transfer rates offered by the SanDisk Extreme cards. (I'm also choosing to believe that it supports the SanDisk Extreme PRO cards as well.)

But...the performance measurements tell a different story. Sure, all of the measurements were above average, but were far below the maximum speeds advertised on the package. I was, frankly, disappointed.

Of course...this card reader was able to get higher speeds with the Extreme 32GB -- even going well past what SanDisk advertised -- so it's not the card reader that's the issue here. (I have two additional samples in the package waiting to be tested -- perhaps I'll get better results with those two.)

Now...if we look at it for what it is? Like I said, all performance metrics were above average -- with write speeds being more than one standard deviation above average -- being beaten out only by one of the Kioxia Exceria G2's. However, when compared to the other name-brand cards I tested, all performance metrics (with the exception of sequential write speeds) were actually below average. Performance was more than enough to merit the U3 and V30 marks, but -- as with the SanDisk Extreme 64GB -- random write performance was well short of what would have been needed for even the A1 mark, let alone the A2 mark.

Endurance tests for all three samples are still ongoing:

Sample #1's first error was an eight-sector wide data shift error during round 2,034; it has survived 2,064 read/write cycles in total so far.
Sample #2 has survived 3,372 read/write cycles and also has not experienced any errors yet.
Sample #3 has not yet reached the 2,000 read/write cycle mark. It is currently expected to reach this point in late June 2024.

Last updated: 5/11/2024

SanDisk High Endurance 64GB

Obtained from: Amazon
Advertised capacity: 64GB
Logical capacity: 63,864,569,856 bytes
Physical capacity: 63,864,569,856 bytes
Fake/skimpy flash: Skimpy (0.21% skimp)
Protected area: 134,217,728 bytes
Adjusted skimp: 0.0019%
Speed class markings: Class 10*, U3, V30*
CID data:
- Manufacturer ID: 0x03**
- OEM ID: 0x5344 (ASCII: SD)
- Product name: 0x5348363447 (ASCII: SH64G)
- Product revision: 0x80

Card #	1	2	3	Average
Price paid	$10.89	$9.99	$9.99	$10.29
Serial number	`0x8eaecd1c`	`0xd78e8cd4`	`0x8655b086`	N/A
Manufacture date	Jun 2023	Jun 2023	Apr 2023	N/A
Sequential read speed (MB/sec)	87.20	82.45	84.94	84.86
Sequential write speed (MB/sec)	47.91	44.31	43.72	45.31
Random read speed (IOPS/sec)	1,323.57	1,389.35	1,543.15	1,418.69
Random write speed (IOPS/sec)	217.65	448.83	433.76	366.75
Read/write cycles to first error	Not yet determined	1,546	159	853
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	SmartQ Single	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back	Not available			N/A
Card front				N/A
Card back				N/A

* The Class 10 and V30 markings appeared on the card, but did not appear on the packaging.

** This manufacturer ID/OEM ID combination is pretty well known to be associated with SanDisk.

Discussion

At one point in time, I decided that I wanted to try out some "high endurance" cards to see if they really held up better on the endurance tests than other cards. For this, I got both this card and the Samsung PRO Endurance. Initially, I only bought one of each; however, I later decided that I should try to get at least three of each model -- at which point I went back and purchased two more of both.

Performance-wise, compared to the other cards I tested, this card did rather well in sequential read/write speeds (with sample #1 getting sequential write speeds that were more than one standard deviation above average), but relatively poorly on random read/write tests. Performance was more than enough to qualify for the Class 10, U3, and V30 markings that it carried. Compared to just the name brand cards, this card performed about average on the sequential write tests, and below average on sequential read and random read/write tests. However, if I stop to think about it for a minute, this makes sense: these cards were probably designed to be used in things like security cameras or dashcams, where video is constantly being recorded to the card and old footage is being overwritten. This type of activity involves a lot of sequential writing, so a card being used for this type of activity benefits from having better sequential write speeds.

Endurance tests are still ongoing for these cards. As of this writing:

Sample #1 has survived 4,597 read/write cycles without issues.
Sample #2's first error was a six-sector wide data shift error during round 1,547; it has survived 1,727 read/write cycles in total so far.
Sample #3 suffered an 8-sector wide data shift error after only 159 read/write cycles; it has also endured 1,727 read/write cycles total so far.

The card's packaging (as well as the product brief on Western Digital's website) offers up some information on how long this card should be expected to last: it shows "up to 5,000 hours of continuous video recording". A footnote on the back of the package indicates that this measurement assumes video encoded at 26Mbps -- which would come out to 93,600Mb/hour (or 11,700MB/hour). Thus, 5,000 hours of video would consume 58,500,000MB (or 58.5TB) of space. Given the capacity of this device, this comes out to just 916 read/write cycles. This is less than half of the 2,000 read/write cycle target we're going for (oof), and only 2 out of the 3 samples I tested managed to make it past this point (double oof).

Overall, this is not a bad card in terms of speed -- it gets pretty good write speeds and average read speeds -- but I'm disappointed when it comes to endurance. Only one of the three managed to make it past the 2,000 read/write cycle mark. On top of that, SanDisk set the bar for "high endurance" pretty low with this card. If you're going to buy this card, I wouldn't expect it to last any longer just because it's a high endurance card.

Last updated: 5/11/2024

SanDisk Industrial 8GB

Obtained from: Amazon
Price paid: $8.17
Advertised capacity: 8GB
Logical capacity: 7,948,206,080 bytes
Physical capacity: 7,948,206,080 bytes
Fake/skimpy flash: Skimpy (0.65% skimpy)
Protected area: 50,331,648 bytes
Adjusted skimp: 0.018%
Speed class markings: Class 10, U1
CID data:
- Manufacturer ID: 0x03*
- OEM ID: 0x5344 (ASCII: SD)*
- Product name: 0x5341303847
- Product revision: 0x80

* This manufacturer ID/OEM ID is pretty well known to be associated with SanDisk.

Sample #	1	2	3	Average
Manufacture date	Mar 2019	Mar 2019	Apr 2019	N/A
Serial number	`0xcc54e0d3`	`0x8b4dd1bf`	`0x640953d9`	N/A
Sequential read speed (MB/sec)	87.62	88.48	88.02	88.04
Sequential write speed (MB/sec)	30.11	33.03	28.34	30.49
Random read speed (IOPS/sec)	1,576.83	1,667.88	1,476.55	1,573.75
Random write speed (IOPS/sec)	321.35	350.69	254.73	308.92
Read/write cycles to first error	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Read/write cycles to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Total days to complete failure	Not yet determined	Not yet determined	Not yet determined	Not yet determined
Card reader used	JJS CR-UTC4AC	JJS CR-UTC4AC	JJS CR-UTC4AC	N/A
Package front				N/A
Package back				N/A
Card front				N/A
Card back				N/A

Ok...why did I buy this one? Because I wanted to see what other offerings SanDisk has, but also because I think that at this point, I'm just on a mission to figure out who makes the most reliable microSD cards.

I thought it was interesting that these cards came in a simple plastic case. I'm guessing SanDisk only sells these cards by the tray, and the seller simply repackaged them to sell them individually.

As far as performance goes, this card is almost the definition of the "average" card. Sequential read speeds were slightly above average, while all other performance metrics were right around average. As of the time of this writing, the overall performance score for this card was -0.019 -- remember that under my rating system, a score of zero represents a perfectly average score. And, keep in mind that the range of scores (for all cards) was from -1.50 to 1.87 -- so a score of -0.019 is about as close to a perfectly average score as you can get. (Technically the Microdrive "Bart Simpson" 16GB got closer to 0 than this one did -- with a score of 0.0097 -- but this one was the second-closest.)

Endurance tests for this card are still ongoing. All three samples made it past the 2,000 read/write cycle mark without errors, making it only the third model in my collection to do so. Sample #1 has currently survived 8,246 read/write cycles; sample #2 has survived 9,291 read/write cycles; and sample #3 has survived 14,846 read/write cycles. None of the three has experienced any errors so far.

As it so happens, Western Digital (who now owns the SanDisk brand) publishes a product brief for these cards. How do my results stack up against what Western Digital advertises? (For the record, the cards I have are model number SDSDQAF3-008G-I.)

First, let's look at performance. The product brief says that these cards should be able to get up to 80MB/sec in sequential read speeds and 50MB/sec in sequential write speeds. My samples definitely hit 80MB/sec in sequential read speeds, but didn't make it anywhere close to the 50MB/sec in sequential write speeds that they advertised.

Next, let's look at endurance. Western Digital says that these cards are supposed to be able to endure 384TBW (terabytes written). (They don't specifically define what a TB is -- whether it's one trillion bytes or 1,024⁴ bytes -- but seeing as how they do have footnotes that define 1 MB = 1,000,000 bytes and 1 GB = 1,000,000,000 bytes, I think it's reasonable to assume that they're also using a definition of 1 TB = 1,000,000,000,000 bytes.) Given the physical user area on the device, this means that the device should be able to endure at least 48,313 read/write cycles. We're nowhere near that point with any of our three samples yet, and we won't be for a while: sample #3 will likely be first to hit that mark, but right now it looks like this won't happen until early October 2024. This will be followed by sample #2 in April of 2025, then sample #1 in May 2025.

Overall, this card only scored about average in terms of speed. However, it has shined in terms of endurance. If you're looking for something is going to work reliably for a long time, this is the card to go with. The biggest disadvantages here are going to be getting a hold of them: they're going to be pricier, and you'll either have to buy them in bulk quantities directly from SanDisk, or buy them from specialty electronics retailers (like Mouser or DigiKey).

Last updated: 5/11/2024

SanDisk Ultra 32GB

Obtained from: AliExpress
Price paid: $6.49
Advertised capacity: 32GB
Logical capacity: 31,914,983,424 bytes
Physical capacity: 31,914,983,424 bytes
Fake/skimpy flash: Skimpy (0.27% skimp)
Protected area: 83,886,080 bytes
Adjusted skimp: 0.0035%
Speed class markings: Class 10, U1*, A1
CID data:
- Manufacturer ID: 0x03**
- OEM ID: 0x5344 (ASCII: SD)**
- Product name: 0x5344333247 (ASCII: SD32G)
- Product revision: 0x85

* The U1 marking appeared on the card, but did not appear on the package.

** This manufacturer ID/OEM ID is pretty well known to be associated with SanDisk.

Discussion

The SanDisk Ultra has been my go-to SD card for a number of years now. I run a farm of single-board computers, and I've been primarily using these cards (in the 16GB denomination) as the primary storage device for these devices -- and in general, I've found them to be cheap and reliable. I've had good luck with them, but I wanted to be objective here and make sure that I ran these through the same paces as the other cards in my collection.

Performance-wise, these cards did well in both sequential read and random read/write speeds, but slightly below average in sequential write speeds. Both samples tested so far performed more than one standard deviation above average in random read speeds, with sample #1 performing more than two standard deviations above average. This was enough to merit the Class 10 and U1 markings; however, it fell short of the 500 IOPS/sec of random write performance required for the A1 mark. I'll throw in my standard "perhaps this card would have done better if it had been tested under proper conditions" disclaimer here -- sample #1 was close enough that this may actually be true.

This is another UHS-I card that advertises speeds higher than what should be possible under the UHS-I standard: the package advertises (in Chinese) "speeds up to 120MB/second". To give this card a fair chance, I tested one of them using one of the SanDisk MobileMate readers, but it didn't seem to perform significantly better with this reader than it did with the Togconn or JJS readers.

The first error for samples #1 and #2 was a data shift error. Curiously, both samples died when I plugged new JJS CR-UTC4AC card readers into nearby USB ports -- which leaves me wondering if (a) these readers are creating some sort of surge on the USB bus, (b) the particular USB hub where this issue occurred didn't electrically isolate the USB ports from each other, and (c) the card readers themselves failed to stop the surge from going through to the cards. But that's just speculation. However, embeddedTS once tested a number of SanDisk cards (though they didn't specify exactly which model/capacity) and noticed that some of them would fail during a brownout -- so perhaps plugging in another reader simply caused a brownout on the USB bus that these cards didn't like.

Sample #3's first errors -- which occurred during round 395 -- were an odd combination: 7 contiguous sectors where the data was shifted by one sector, but also the first four bytes of each sector were all zeroes; followed by 2,048 contiguous sectors where the data was shifted by one sector. It has endured 593 read/write cycles in total so far.

Last updated: 5/11/2024

Sansumg Pro Plus 2TB

Obtained from: AliExpress
Price paid: $4.63
Advertised capacity: 2TB
Logical capacity: 2,147,483,648,000 bytes
Physical capacity: 8,489,271,296 bytes
Fake/skimpy flash: Fake flash
Speed class markings: U3, V30, A2
CID data:
- Manufacturer ID: Unknown*
- OEM ID: Unknown*
- Product name: Unknown*
- Product revision: Unknown*
- Serial number: Unknown*
- Manufacture date: Unknown*
Sequential read speed (MB/sec): 9.98
Sequential write speed (MB/sec): 9.07
Random read speed (IOPS/sec): 574.04
Random write speed (IOPS/sec): 0.79
Read/write cycles to first error: 1,970
Read/write cycles to complete failure: 1,970
Total days to complete failure: 45
Card reader used: SmartQ Single**
Package front:
Package back: Not available
Card front:
Card back:

* These values are unknown because I didn't have the idea to dump the card registers until later in this project; by the time I thought to do it, this card had already died.

** I think. Seeing as how this is one of the first cards I tested, I would have only had SmartQ Single's at that point in time.

Discussion

Before I go any further: yes, "Sansumg" is misspelled. No, it's not a typo. This is one of the first cards that I bought off of AliExpress, and I spotted the misspelling immediately -- in fact, it was the whole reason I ordered it. The makers of this card even went so far as to try to make their logo look like Samsung's -- taking Samsung's logo and switching the "M" and "N" around.

Being fake flash, this card did about as abysmally as I expected on its performance tests -- maybe even worse. All performance metrics were more than one standard deviation below average. This is not a unique distinction -- it's shared by a few other cards in my collection -- however, what does make this card stand apart is the fact that it had the lowest score in the sequential read test out of any of the cards I tested. In fact, not only does it not qualify for any of the performance marks that it carries, but it didn't even meet any single threshold for any of its performance marks.

I was about to be impressed by how long this card managed to last in its endurance tests; however, it failed just shy of the 2,000 read/write cycle mark. It failed pretty suddenly, and just suddenly stopped responding to commands from the system.

Last updated: 2/25/2024

"Sony" 32GB

Obtained from: AliExpress
Price paid: $4.66
Advertised capacity: 32GB
Logical capacity: 31,266,439,168 bytes
Physical capacity: 31,266,439,168 bytes
Fake/skimpy flash: Skimpy (2.29% skimp)
Protected area: 83,886,080 bytes (inaccessible)
Speed class markings: Class 10, U1, A1
CID data:
- Manufacturer ID: 0x00
- OEM ID: 0x3432 (ASCII: 42)
- Product name: 0x5344313647 (ASCII: SD16G)
- Product revision: 0x20
- Serial number: 0x00000378
- Manufacture date: Sep 2023
Sequential read speed (MB/sec): 67.63
Sequential write speed (MB/sec): 17.57
Random read speed (IOPS/sec): 1448.45
Random write speed (IOPS/sec): 273.42
Read/write cycles to first error: 518
Read/write cycles to complete failure: 1,749
Total days to complete failure: 136
Card reader used: JJS CR-UTC4AC
Package front:
Package back:
Card front:
Card back:

Discussion

This is another card that I bought for two reasons: to see if I could find genuine flash and fake flash in the same brand, and to evaluate a knockoff brand. I believe I succeeded on both points here.

Knockoff brands like these usually follow a pretty similar M.O.: they take the name of a brand that's a pretty well known electronics manufacturer, but who isn't known for producing flash media (or usually any storage media whatsoever). In this respect, Sony fits this bill. Perhaps they can do this so that it's harder to disprove that their product is genuine -- if there's no genuine article to compare it to, then it's harder for someone to say that their product isn't genuine. That said, I heavily suspected that this card was going to be a knockoff when I ordered it.

This card is another example where the manufacturer set the manufacturer ID to all zeroes, likely in an attempt to mask the manufacturer's true identity. However, there are a number of cards in my collection that all share the same OEM ID and product ID, including the three Cloudisk cards, one of the Auotkn Extreme 8GB cards, and one of the Bekit 8GB cards -- I'm willing to bet that all of these were made by the same manufacturer.

Performance on this card was mediocre overall. Read performance (both sequential and random) and random write performance were all average or slightly below average, while sequential write performance was pretty solidly below average. Compared to the other knockoff cards I evaluated, however, this card actually did quite well: sequential read and random write speeds were more than two standard deviations above average, and sequential write and random read speeds were one standard deviation above average. These scores were enough to merit the Class 10 and U1 markings it carries; however, both random read and random write performance fell short of the threshold for the A1 marking. I honestly don't think there's any way that this card would qualify for the A1 marking -- and I can say that because I'm not scared of "Sony" coming after me for that comment.

On the endurance front -- most of the cards I've tested have failed before they reached the 50% (the point where 50% of the sectors on the device have been flagged as "bad" due to verification failures or I/O errors). To this one's credit (or not? I'm not sure), it kept chugging along right up until it hit that threshold. Don't get me wrong -- this card is still nothing to write home about, especially since it couldn't go 2,000 read/write cycles without an error...or at all. Here's what the progression for this card looked like:

Last updated: 4/2/2024

"Sony" 1TB

Obtained from: AliExpress
Price paid: $5.17
Advertised capacity: 1TB
Logical capacity: 1,073,742,872,576 bytes
Physical capacity: 31,224,393,216 bytes
Fake/skimpy flash: Fake flash
Protected area: 0 bytes
Speed class markings: Class 10, U1, A1
CID data:
- Manufacturer ID: 0x00
- OEM ID: 0x0000
- Product name: 0x0050ffffb0
- Product revision: 0x00
- Serial number: 0x12800188
- Manufacture date: Aug 2013
Sequential read speed (MB/sec): 11.83
Sequential write speed (MB/sec): 10.08
Random read speed (IOPS/sec): 492.28
Random write speed (IOPS/sec): 6.01
Read/write cycles to first error: 359
Read/write cycles to complete failure: 460
Total days to complete failure: 48
Card reader used: JJS CR-UTC4AC
Package front:
Package back:
Card front:
Card back:

Discussion

Like the smaller 32GB sibling, I bought this to see if I could find genuine flash and fake flash in the same brand, as well as to evaluate some knockoff brands. Unsurprisingly, this card turned out to be fake flash -- which I heavily suspected would be the case when I ordered it. It was a bit of a surprise that it turned out to have 32GB of space -- as opposed to some of the other fake cards I have, which were 4GB and 8GB.

This card did pretty abysmally in terms of performance, falling more than one standard deviation below average on all performance metrics. It even fell well below average when compared to the other knockoff cards I evaluated. It was barely enough to merit the Class 10 and U1 marks that it bore, but it fell well short of the speeds it would need to merit the A1 mark.

Where this card surprised me was on its endurance tests: it only managed to go for 359 read/write cycles before it started showing issues, and only 460 cycles before it stopped responding to commands. This puts it well below average, even when compared to the other knockoff cards I tested, and -- as of the time of this writing -- the knockoff card that has survived the least number of read/write cycles before failing.

Last updated: 3/15/2024

"Xiaomi" 16GB

Obtained from: AliExpress
Price paid: $5.38
Advertised capacity: 16GB
Logical capacity: 16,106,127,360 bytes
Physical capacity: 4,026,329,600 bytes
Fake/skimpy flash: Fake flash
Protected area: 0 bytes
Speed class markings: Class 10, U3, A1
CID data:
- Manufacturer ID: 0x00
- OEM ID: 0x0000
- Product name: 0x0000000000
- Product revision: 0x00
- Serial number: 0x000048bd
- Manufacture date: Jan 2023
Sequential read speed (MB/sec): 18.96
Sequential write speed (MB/sec): 7.29
Random read speed (IOPS/sec): 1028.13
Random write speed (IOPS/sec): 1.48
Read/write cycles to first error: 0
Read/write cycles to complete failure: 6,618
Total days to complete failure: 90
Card reader used: JJS CR-UTC4AC
Package front:
Package back:
Card front:
Card back:

Discussion

This is another card that I purchased for a couple of reasons: first, because I wanted to see if it was possible to find both fake flash and non-fake flash in the same brand, but also because I wanted to evaluate a few knockoff cards. (For those of you outside of China: Xiaomi is a pretty well known electronics maker in China -- many have dubbed it "the Apple of China" -- but from what I can tell, they don't sell microSD cards...or any storage products whatsoever. This seems to be a pretty common M.O. for knockoff media sellers -- they will label something using the name of a pretty well known electronics manufacturer, even though the manufacturer they're knocking off isn't known for making flash media.)

I purchased two samples: a 16GB and a 2TB. What surprised me is that both samples were fake flash -- I expected the 2TB card to be fake, but I didn't expect the 16GB card to be fake.

Performance metrics were -- as to be expected -- pretty abysmal. All performance metrics were below average; and with the exception of the random read metric, all performance metrics were more than one standard deviation below average. Scores were not good enough to qualify for any of the performance marks that it bore. Perhaps it would have done better had it been tested under proper conditions, but I highly doubt it.

On the endurance front, this card started having issues almost immediately. During the first round of testing, a 1.8MB "hole" appeared, where reads from sectors in the hole resulted in all zeroes being read back. This hole persisted in size and location during subsequent rounds. Several more such holes (of varying sizes) appeared during subsequent rounds, but did not persist for more than a few rounds. Additionally, data verification failures happened during a few rounds of testing, affecting ranges in size from a few hundred kilobytes to several megabytes. Curiously, however, these issues stopped between rounds 1,599 and 5,239 (with the exception of the original hole discovered during the first round); at this point, the card began to suffer a lot of bit flip errors. It finally failed during round 6,619 -- when any attempt to write to the card resulted in an I/O error.

Given that the hole that appeared during the first round of testing -- which I'll call the "origi-hole" -- persisted during all rounds of testing, and combined with the fact that all subsequent errors happened after the location of the origi-hole, it could be that the origi-hole marks the end of the intended physical space, and that the remaining space is being used for wear leveling. I haven't seen any other cards exhibit this kind of behavior. If that's the case, then the true size of the device would be 3,824,201,728 bytes instead. But...that's just my guess.

Last updated: 3/15/2024

"Xiaomi" 2TB

Obtained from: AliExpress
Price paid: $5.89
Advertised capacity: 2TB
Logical capacity: 2,147,483,648,000 bytes
Physical capacity: 4,010,738,176 bytes
Fake/skimpy flash: Fake flash
Protected area: 0 bytes
Speed class markings: Class 10, U3, A1
CID data:
- Manufacturer ID: 0x00
- OEM ID: 0x0000
- Product name: 0x0000000000
- Product revision: 0x00
- Serial number: 0x00000ee2
- Manufacture date: Aug 2023
Sequential read speed (MB/sec): 21.33
Sequential write speed (MB/sec): 10.29
Random read speed (IOPS/sec): 655.33
Random write speed (IOPS/sec): 1.94
Read/write cycles to first error: 49
Read/write cycles to complete failure: Not yet determined
Total days to complete failure: Not yet determined
Card reader used: JJS CR-UTC4AC
Package front:
Package back:
Card front:
Card back:

Discussion

Once again, this is a card I purchased -- along with the smaller 16GB sibling -- to see if I could find fake flash and genuine flash, and to have some knockoff cards in my results. While I didn't expect the 16GB version to be fake flash, I did expect the 2TB to be fake. Admittedly, however, I was a little surprised to see that they were both 4GB -- but perhaps I should have expected that. Surprisingly, this earned it two titles: highest price per gigabyte (at $1.469 per gigabyte), and skimpiest card (offering just 0.2% of the advertised capacity).

Performance-wise, sequential read and write scores were more than one standard deviation below average. However, when compared to the other knockoff cards in my collection, they were pretty close to average. Random read/write speeds were below average as well, even when compared to the other knockoff cards. Performance was good enough to meet the qualifications for the Class 10 mark, but not good enough for the U3 or A1 marks. I'll throw in my standard "perhaps it would have done better under the right testing conditions" disclaimer -- but I highly doubt it would have made a difference.

Endurance tests for this card are still ongoing. The card experienced a 15MB-wide data verification error during round 50; I don't know exactly where on the card these errors took place, because the version of my program that I was running at the time didn't log this information. Curiously, however, the sectors in question here will generally verify correctly on subsequent rounds of testing; but every few rounds, they will again fail to verify correctly, then go back to being "good" on the next round. The number of rounds between this happening seems to be variable. I'm not sure what to make of this -- if this were an artifact of wear leveling, I'd expect the "bad" sectors to reappear elsewhere on the card, which they don't seem to do. The fact that the reappear in the same place every time might be an artifact of the fact that I'm writing to the entire user area of the card. It's still chugging along, however -- it has survived 12,367 read/write cycles so far, and the total number of sectors flagged as "bad" is currently just over the 1% mark.

Last updated: 5/11/2024

XrayDisk High Endurance 32GB

Obtained from: AliExpress
Price paid: $3.70
Advertised size: 32GB
Logical capacity: 31,275,876,352 bytes
Physical capacity: 31,275,876,352 bytes
Fake/skimpy flash: Skimpy (2.26% skimp)
Protected area: 134,217,728 bytes
Adjusted skimp: 1.84%
Speed class markings: Class 10, U1, A1
CID data:
- Manufacturer ID: 0x6f
- OEM ID: 0x0303
- Product name: 0x5344414243 (ASCII: SDABC)
- Product revision: 0x10

Discussion

This is an off-brand product that came up early in my AliExpress searches, and I think the "High Endurance" part of the name may have been what inspired me to obtain the SanDisk High Endurance and Samsung PRO Endurance to have some name-brand samples to compare it to.

Performance-wise, sequential read and random read speeds were close to average. Sequential write speeds were above average, while random write speeds were below average. Compared to the other off-brand cards I tested, however, sequential speeds and random read speeds were above average, while random write speeds were below average. Performance on all three cards was good enough to qualify for the Class 10 and U1 markings that they carried, but no single card scored well enough to qualify for the A1 marking. Given that all three cards got close to the 1,500 IOPS/sec threshold for random read operations, and sample #2 got somewhat close to the 500 IOPS/sec threshold for random write operations, it's possible that they would have performed better under proper testing conditions.

I wish measurements had been clustered closer together -- but the fact that they're not could indicate inconsistencies with how these cards were manufactured.

What really disappointed me, however, was endurance: all three of these cards only managed to go for a few read/write cycles before hitting their first error. The fact that this happened with all three cards and that the data points are so close together points to a possible quality control issue (although who am I kidding, these cards didn't go through any quality control). On the bright side, these cards did display some ability to self-heal, as all three cards stopped displaying errors after round 136. However, endurance tests are still ongoing. As of the time of this writing:

Sample #1 experienced a 1,258-sector wide error during round 13. I don't know the nature of the error, because the version of the program I was using at the time didn't log this information. It has survived 7,120 read/write cycles so far. (In the interests of full disclosure, I will say that there were more errors after round 136, but those were attributable to problems with the portions of my code that handles device disconnects/reconnects. Once those problems were fixed, the card stopped experiencing errors.)
Sample #2 experienced a series of bit flip errors affecting 8 sectors starting in round 3; it has survived 3,369 read/write cycles total so far and has not experienced any further issues since then.
Sample #3 experienced a series of bit flip errors affecting 18 sectors during round 68, and a couple more data verification errors during rounds 761, 831, and 1,148. (Although given that the actual data read back during round 1,148 was right shifted from the expected data by exactly 4 bits, and the device experienced an error immediately afterwards that required it to be reset, I think it's reasonable to assume that either the card or the reader missed a clock cycle while returning data.) It has survived 2,179 read/write cycles total so far.

Last updated: 5/11/2024

Known Issues

If I'm looking at this from a scientific point of view, there are a number of issues with the way I conducted this test. I didn't have clear goals when I started this project, and that probably contributed to these issues. Below are some issues I can think of.

Card Readers

I experimented with various card readers during the course of this experiment, trying to determine which ones would not only perform best, but also allow me to test as many cards as possible simultaneously. This resulted in using a mix of various card readers, which may have affected my results. While the obvious difference (if any) would be in performance, it's also possible that some of the other errors I encountered were due to the card reader rather than the card. (This was certainly the case with the SmartQ Single due to its tendency to randomly stop working: if it stopped working during a write operation, a certain amount of data -- usually around 1MB -- would be lost. I had to account for this in my code by rewriting the missing data when the card reader was reconnected.)

Performance Test Method

The SD Card Association's Physical Layer Specification provides a number of criteria for how speed tests are to be performed -- including block size, commands to be used, preconditioning of the card, size of write operations, size of the area to be written to, length of the test, etc. These criteria were not followed for a number of reasons -- primarily owing to the fact that USB card readers don't expose a lot of the functionality needed. I would like to develop something that could run on an FPGA and run the tests using the conditions prescribed in the specification. (I have an FPGA starter kit that I'm learning on now, but I will need a faster one at some point in the future, as I can only run the SD bus at 25MHz with the one I have. Side note: I did try to do this with an Arduino Duo as a proof of concept, but I was only able to run the SD bus at about 10KHz with it -- and the clock signal was not very stable with it.)

Endurance Test Method

The endurance test is a continuous test -- during each round, the host overwrites the entire user area of the card, as fast as conditions will allow. Once this process has finished, the host immediately proceeds to read back the entire user area of the card -- again, as fast as conditions will allow. While this is representative of some uses cases, it fails to take some other common use cases into account.

One such use case would be in a mobile phone or mobile gaming console (yes, I'm looking at you, Nintendo Switch), where the card would have a tendency to heat up and cool down according to when the user uses their device. A possible follow-up experiment would be to perform an endurance test where testing is paused (and the device is allowed to cool down) between every round or every few rounds of testing, or where the card is removed from the card reader and placed in a cold environment (such as a refrigerator or freezer) for a certain amount of time before being returned to the card reader.

Another such use case would be in a digital camera, where the ability to retain data for long periods of time is an important factor. A possible follow-up experiment would be to perform an endurance test where the card is overwritten, then placed in storage for a certain amount of time, then read back and compared to the original data written.

Host Machines Used

While I don't think it had much of an influence on my results, I did use two different machines for this experiment. Let's face it -- I'm trying to do this on the cheap, so I grabbed a couple of old laptops I had sitting around, put RAM and a hard drive back in one of them, installed Ubuntu on them, and put them to work. The first laptop I used was an MSI GE62VR-7RF that had an i7-7700HQ; the other one was a Lenovo Y580 that had an i7-3630QM. Theoretically there could have been some irregularity in the results caused by, say, differences in the USB host controller -- but at this point in time, I don't have any reason to suspect this is the case.

Ubuntu Version Used

As I mentioned above, I used two different machines for running this experiment. I set them up at different times, as I didn't expect that I was going to need a second machine. I apparently set them up with two different versions of Ubuntu: for the first machine (which was the MSI, by the way), I grabbed a Ubuntu boot stick I had laying around -- which had Ubuntu Desktop 20.04 on it -- and installed that. Since I didn't need/want the desktop environment on there, I used Ubuntu Server 22.04 for the second machine. The two are running practically the same Linux Kernel version (one is running 5.15.0-79-generic, the other is running 5.15.0-78-generic). Again, it's possible that the difference between the two introduced some irregularity into my results -- but I don't have any reason to suspect this is the case.

Heat Dissipation

These cards get hot. Really hot. How hot? This hot:

For you non-Americans, here it is in non-Freedom units:

Now...is it an issue? I don't know. I spot checked the specs for a few of the cards I'm testing, and they all listed the maximum operating temperature as 185ºF (85ºC) -- and my measurements were well below that. But does that mean that all of my cards are rated up to that temperature? Well...they probably are, but I don't know for sure.

This rig is in a small closet (probably less than 40 sq. ft.) with its own air conditioner, constantly trying to keep the room at 72ºF -- but it can only do so much. And I just don't know if that amount of heat is causing issues with the cards themselves, or if it's causing the USB hub that it's attached to (which is absorbing a lot of this heat).

Conclusion

I think there's a number of conclusions I could make from this data:

In terms of performance, name-brand cards (regardless of whether they come from Amazon or AliExpress) are generally better than off-brand cards, and off-brand cards are generally better than knock-off cards.
If it's a knock-off card, expect it to be fake and low-quality flash.
And, of course, if the price sounds too good to be true for the capacity, it's probably going to be fake flash -- but there are exceptions to be found.

There are a few comments I want to make about certain brands in particular -- but I don't want to say anything until I have more data from the endurance tests.

I think I'll conclude this by leaving you with words I once heard a wise person say:

Further study is needed.