Most advice on the best microSD card for Raspberry Pi boards still assumes the card boots an OS and then sits mostly idle. That stopped being true once people began running Home Assistant, Frigate or a k3s node from the same slot around the clock. A 24/7 board writes small random blocks all day, and the big MB/s figure on the packaging describes none of that. The speed class covers sequential video recording, the A1 or A2 mark covers random I/O, and an endurance rating says how many hours of writing the maker will stand behind.
This guide explains what those marks buy you on a Pi 5, picks six cards for three jobs, and shows how to prove a new card is genuine. We built a fake 8 GB card from a 1 GB device and ran it through f3 and the Raspberry Pi SD speed test. Only one of them caught it. The f3 behaviour shown here was checked against f3 10.0 on Fedora 45 in October 2026, the same week the prices below were taken.
Which microSD card should you buy for a Raspberry Pi?
For a Raspberry Pi 5 that boots from the card, buy the official Raspberry Pi SD card from an approved reseller. It is the card the Raspberry Pi kernel’s command queuing allow-list was written for, and queuing is the feature that lets an A2 card hit its random I/O numbers. If you want to order from Amazon, the SanDisk Extreme is the A2 card we would take, with the caveat that the kernel runs it without queuing. If the Pi does nothing but write to the card all day, the decision changes, and an endurance-rated card is worth more than random I/O speed. Match the card to what the board does:
- Raspberry Pi 5 general use: Raspberry Pi SD card (32, 64 or 128 GB), on the Pi 5 kernel’s queuing allow-list, bought from an approved reseller.
- Best A2 card on Amazon: SanDisk Extreme 128GB, rated to the A2 minimums with a lifetime limited warranty, approx $40 to $46.
- Home Assistant or anything that writes 24/7: Samsung PRO Endurance 128GB, rated for 70,080 hours of recording, approx $70 to $80.
- Fastest sequential speed: Samsung PRO Plus 128GB, A2, but its warranty excludes write-intensive use, approx $50 to $60.
- Cheapest card rated for continuous writes: SanDisk High Endurance 128GB, approx $35 to $40.
- Outdoor boxes and freezing sheds: Kingston Industrial 64GB, pSLC flash rated from -40 to 85 °C, approx $150 to $160 from a marketplace seller.
Prices move weekly, so check the live listing before you buy. The official card has no Amazon link on purpose. The only Amazon US listing we found was a third-party seller charging far more than Raspberry Pi’s approved resellers do.
How we picked these cards
Every rating in this guide comes from the maker’s own product page or datasheet. Every price and stock state comes from the live Amazon listing for the exact SKU, checked on 27 October 2026. We did not benchmark these cards on a Pi 5 ourselves, so any speed figure we quote is the maker’s rating or names who measured it. What we did test in the lab is the part no spec sheet covers: how a fake card behaves and which checks catch it. The sources split like this:
- Class ratings and endurance: Samsung, SanDisk and Kingston product pages and the Kingston SDCIT2 datasheet.
- A2 behaviour on a Pi: the SD Association’s class definitions, Raspberry Pi’s October 2024 write-up of command queuing on the Pi 5, and the card allow-list in the current Raspberry Pi kernel source.
- Fake-card detection: our Fedora 45 lab VM, an emulated 8 GB counterfeit, f3 and the fio job from the Raspberry Pi diagnostics tool.
We left out cards that only had marketplace listings at inflated prices, with one exception. The Kingston Industrial stays because, among the cards we considered, it was the one with an industrial temperature range and pSLC flash from a maker whose consumer cards you already know. The SanDisk MAX Endurance (60,000 hours at 128 GB) would have been a strong second endurance pick. On the day we checked, though, only a marketplace seller had it, at $85 to $95 with no stock date, which is more than the Samsung it competes with.
How the six cards compare
The columns below are the ratings that change a buying decision for an always-on board, with the official Raspberry Pi card added for reference. Endurance is quoted at 128 GB because the makers scale it with capacity, so a headline figure is usually the largest card’s:
| Card | App class | Speed class | Rated endurance | Operating temp | Warranty |
|---|---|---|---|---|---|
| Raspberry Pi SD Card | A2 | U3, V30 | Not published | -25 to 85 °C | Not published |
| SanDisk Extreme | A2 | U3, V30 | Not published | -25 to 85 °C | Lifetime limited |
| Samsung PRO Endurance | None | U3, V30 | 70,080 h (128 GB) | -25 to 85 °C | 5 years |
| Samsung PRO Plus | A2 | U3, V30 | Not published | -25 to 85 °C | 10 years, excludes write-intensive use |
| SanDisk High Endurance | None | U3, V30 | 10,000 h (128 GB) | -25 to 85 °C | 2 years |
| Kingston Industrial | A1 | U3, V30 | 30,000 P/E cycles (pSLC) | -40 to 85 °C | 3 years |
Read the table by column, not by row. None of the endurance-rated cards carries an A2 mark, and none of the A2 cards publishes an endurance figure. So on Amazon today you choose between a card that promises random I/O speed and a card that promises to keep writing. Only the Kingston promises both a little (A1 and pSLC flash), and it costs about twice as much as the Samsung PRO Endurance and close to four times the SanDisk Extreme. That trade is the whole guide in one line, and the sections below explain which side each workload should fall on.
Raspberry Pi SD Card: why the Pi 5 kernel trusts it with queuing
The official card wins on a Pi 5 because the kernel will queue commands on it and on almost nothing else you can buy. Since January 2025 the Raspberry Pi kernel keeps an allow-list for SD command queuing, after Raspberry Pi found cards of the same make and model with latent queuing bugs that caused hangs and data corruption. In the 6.12 kernel branch the list holds only Raspberry Pi’s own A2 cards, made by Longsys, and the newer 6.18 branch adds newer Transcend cards (hardware revision 2.0, made from April 2026). So this is the card that gets its rated random I/O on a stock install.
Raspberry Pi’s product brief quotes 5,000 random read and 2,000 random write IOPS for the card on a Pi 5, and says it will stay in production until at least January 2028. It comes in 32, 64 and 128 GB. It is for anyone booting a Pi 5 from a card who wants the best random I/O a card can give on that board without touching kernel settings.
Skip it if you need an endurance rating, because Raspberry Pi does not publish one, or if you can only buy from Amazon. The single Amazon US listing we found was a third-party seller at more than twice the reseller price. Buy it from an approved reseller listed on Raspberry Pi’s SD card page.
SanDisk Extreme: what you get from an A2 card on Amazon
The SanDisk Extreme is the A2 card we’d buy on Amazon because Amazon sells it directly and SanDisk rates it to the full A2 minimums. Raspberry Pi’s October 2024 blog named the Extreme and Extreme Pro as cards that performed well with queuing, but that was before the allow-list. On a current Raspberry Pi OS kernel the Extreme runs with the host’s software queue instead, so expect at least A1-level random I/O and less than its A2 rating.
SanDisk rates the line at the A2 minimums of 4,000 random read and 2,000 random write IOPS, with U3 and V30 for sequential writes. The current Amazon SKU (SDSQXH9) is a newer revision than the one on SanDisk’s spec page. Its listing claims higher MB/s figures we could not confirm with SanDisk, so we would ignore the headline speed. The kernel also flags Extreme and Extreme Pro A2 cards made in 2019 and 2020 for a cache-flush bug in queued mode, which is one more reason to buy a current card rather than old stock. It is for anyone booting a Pi 4 or Pi 5 from a card who wants one Amazon card that does everything reasonably.
Look elsewhere if the board will log or record continuously for years. SanDisk publishes no endurance rating for the Extreme, so it makes no promise about how long it survives a database writing every few seconds. Price: approx $40 to $46. Check the live price on Amazon.
Samsung PRO Endurance: why it suits Home Assistant better than a faster card
Home Assistant’s recorder writes state changes to its SQLite database all day. On a Pi that runs only Home Assistant, a worn-out card is a likelier failure than a slow one. That is why the Samsung PRO Endurance is our pick for a dedicated Home Assistant Pi. Samsung rates the 128 GB card for 70,080 hours of continuous recording, about eight years, and backs it with a 5-year warranty written for that kind of use.
The trade is speed. Samsung rates it at 100 MB/s read and 40 MB/s write and does not publish an A-class, so it makes no promise about random I/O. Home Assistant’s own Raspberry Pi install page asks for at least 32 GB and says that, ideally, the card should be A2. We’d still take endurance over A2 on a single-purpose box, because a slower first boot and add-on install costs minutes once, while a worn card costs the whole configuration. Keep backups off the card either way. The Amazon title for this SKU (MB-MJ128KA) lists U1 and V10, while Samsung’s page and the card face say U3 and V30, so trust the card.
Skip it if the Pi also runs containers, a desktop or a k3s node, where random I/O matters every day and an A2 card feels noticeably faster. Price: approx $70 to $80. Check the live price on Amazon.
Samsung PRO Plus: what the 10-year warranty does not cover
The PRO Plus is the fastest card here on paper, rated at 180 MB/s read and 130 MB/s write with the A2, U3 and V30 marks, and it carries a 10-year warranty. The catch is in Samsung’s warranty terms, which exclude continuous recording and write-intensive use such as servers and data logging. An always-on Pi running Home Assistant falls squarely inside that exclusion, so the long warranty mostly protects a camera or a Pi you use as a desktop.
Raspberry Pi’s kernel source has a specific note on this card too. It marks Samsung PRO Plus, EVO Plus and PRO Ultimate cards made in 2023 as claiming to flush their cache correctly and then becoming unresponsive, so it turns the card’s write cache off on those. The PRO Plus is also not on the queuing allow-list, so on a Pi it behaves as a fast sequential card rather than a fast random one. Buy it for a Pi you reimage often or use as a desktop, where the 130 MB/s write rating shortens every flash and copy.
A Pi that runs 24/7 and counts on that warranty is the wrong home for it. Price: approx $50 to $60 for the 128 GB card Amazon sells directly, which is currently a Sonic the Hedgehog edition of the same card. Check the live price on Amazon.
SanDisk High Endurance: what the cheapest endurance card gives up
The High Endurance is the cheapest card here rated for continuous writing at all. That makes it the right card for a spare Home Assistant Pi, an OctoPrint box or a sensor logger you would rather not overthink. What it gives up is margin: SanDisk rates the 128 GB card for 10,000 hours, about 14 months of nonstop recording, against the Samsung’s 70,080, and the warranty runs two years. The 40,000-hour figure on some listings belongs to the 512 GB card.
Those hours are measured as continuous video recording, which writes far more than a Home Assistant recorder does, so a lightly loaded Pi will outlast the rating by a wide margin. Like the Samsung it has no A-class mark. Skip it for a camera NVR on the card itself, which is the workload the hours rating describes and the one where 14 months is a real limit. Price: approx $35 to $40. Check the live price on Amazon.
Kingston Industrial: what pSLC and a -40 °C rating buy you
The Kingston Industrial is the card for a Pi in a weatherproof box on a pole or in an unheated shed. It is the only one here rated to run from -40 to 85 °C. It uses TLC flash in pSLC mode, storing one bit per cell instead of three, which trades capacity for wear life. That is how Kingston can quote 30,000 program and erase cycles. It also carries the A1 mark, so it promises some random I/O as well.
Two things hold it back as a general pick:
- Price and seller: the 64 GB card was only on Amazon from a marketplace seller, at several times the price of the consumer cards.
- Kingston’s own caveat: the datasheet says Kingston tests its flash cards for consumer use and asks buyers with special applications to contact them.
Pick it when temperature is the problem, not when wear alone is, because the Samsung PRO Endurance answers wear for half the money. Price: approx $150 to $160. Check the live price on Amazon.
What A2 actually changes on a Raspberry Pi 5
A2 pays off fully only when the host takes part, and the Pi 5 is the first Raspberry Pi that can. The SD Association defines A1 as at least 1,500 random read and 500 random write IOPS (4 KB commands) with 10 MB/s sustained. A2 raises that to 4,000 read and 2,000 write IOPS at the same sequential floor. The SD Association’s own page says A2 gets there “by using functions of Command Queuing and Cache” and that an A2 card in a host without that support only guarantees A1.
In October 2024 Raspberry Pi shipped a Raspberry Pi OS kernel that turns those functions on for the Pi 5, and in January 2025 it narrowed which cards get them. On a current kernel the mechanism works in order:
- The card declares itself: an A2 card reports a queue depth of up to 32 tags and support for write caching, extension registers and power-off notification.
- The kernel checks the allow-list: unless the card is on it, queuing is switched off and the card runs on the host’s software queue. The list holds Raspberry Pi’s own A2 cards, plus newer Transcend cards in the 6.18 kernel.
- Reads and writes queue up: on an allowed card the Pi 5 hands it several commands at once, so its controller can reorder them and its cache can absorb small writes.
The Raspberry Pi announcement notes one cost: the kernel limits posted writes to one at a time in queued mode, which costs at most 2 to 3% of sequential write speed. A Pi 4 gets no queuing and runs a slower bus mode. That is why Raspberry Pi quotes 3,200 read and 1,200 write IOPS for its own card on a Pi 4, against 5,000 and 2,000 on a Pi 5. A2 cards still lift older Pis, just by less.
You can opt other A2 cards in with dtparam=sd_cqe=2 in /boot/firmware/config.txt, which allows queuing on every A2 card the kernel does not already know to be bad. The allow-list exists because unvetted cards hung or corrupted data in queued mode, so we would only do that on a Pi whose data you can lose. On a Pi 5 (the option and both log lines are Pi 5 only), check what the kernel decided by searching the kernel log from sudo dmesg for “Command Queue Engine enabled” or “Host Software Queue enabled” after boot.
Why endurance cards are slower, and when that is the right call
Endurance cards are tuned for one workload, a camera writing video sequentially forever, and their ratings are written in hours of that recording. That’s why they carry U3 and V30 for sequential writes and skip the A-class entirely: nothing in a dashcam issues thousands of small random writes per second. On a Pi, the hours figure still matters because flash wears per block written, whatever the pattern, but it tells you nothing about how quickly the card handles a busy database.
So the choice comes down to which failure you’d rather risk. A Home Assistant Pi with a handful of integrations is mostly idle between writes, and the card dying in year two is the outcome that loses your setup, so endurance wins. A Pi running containers, a k3s agent or a desktop does steady random I/O you feel every day, so A2 wins and you plan for replacement. If you can’t decide, it’s usually a sign the Pi has outgrown a card, which is the last section’s subject.
How a fake microSD card passes a speed test
A counterfeit card reports a capacity it doesn’t have, and the commonest trick is to accept writes past the real flash and quietly throw them away. The first gigabyte works, the card formats at full size, and you only find out when files written later read back as garbage. To see which checks catch that, we built one on a Fedora 45 VM with device-mapper. It has 1 GB of real storage followed by 7 GB of a zero target that discards writes and returns zeros. These are the commands from that run:
truncate -s 1G ~/real.img
REAL=$(sudo losetup --direct-io=on -f --show ~/real.img)
printf "0 2097152 linear $REAL 0\n2097152 14680064 zero\n" > ~/fake.table
sudo dmsetup create fakecard ~/fake.tableAsk the device its size and it answers like an ordinary 8 GB card, which is all a phone or a laptop’s file manager ever checks:
lsblk -o NAME,SIZE,TYPE /dev/mapper/fakecardNothing in the answer hints that 7 of those 8 GB don’t exist:
NAME SIZE TYPE
fakecard 8G dmf3probe is the tool built for this. It writes and reads back blocks across the device, works out where the real storage ends, and runs on the unmounted device as root. The --destructive flag skips restoring the original data, so only use it on a card you have nothing on:
sudo f3probe --destructive --time-ops /dev/mapper/fakecardf3probe needed 72 seconds to name the fake, give the real usable size and print the command to fix it:
“Limbo” is f3’s name for exactly this design, where writes beyond the real flash vanish. The usable size of 1.00 GB against an announced 8.00 GB is the number that matters. We also emulated the other common fake, which wraps writes back onto the start of the real flash. f3probe flagged that one too, as “damaged” with a usable size of zero. f3 has its own “wraparound” verdict, so a real card built that way may be reported by that name; our device-mapper emulation is a stand-in, not a card. Either verdict means the same thing to a buyer: return the card.
The diagnostics tool that ships with Raspberry Pi OS runs a different kind of check. Its agnostics fio job writes a 256 MB test file and calls itself a “sniff test” for the A1 class. It passes a card at 10,000 KB/s sequential write, 500 random write IOPS and 1,500 random read IOPS. We took data/sd_bench.fio from that repository and pointed its test directory at the fake card, which we had formatted exFAT and mounted at /mnt/fake:
sed "s#^directory=/var/tmp#directory=/mnt/fake#" ~/sd_bench.fio > ~/sd_bench_fake.fioThen we ran it the way the Raspberry Pi script does, keeping the same five result columns:
sudo fio --output-format=terse --max-jobs=4 ~/sd_bench_fake.fio | cut -f 3,7,8,48,49 -d";"Reading the columns as job name, read KB/s, read IOPS, write KB/s and write IOPS, every threshold clears with room to spare:
prepare-file;0;0;38698;75
seq-write;0;0;39712;9
seq-read;4032984;984;0;0
rand-4k-write;0;0;24925;6231
rand-4k-read;446582;111645;0;0That result is the point of the exercise. fio measures speed and never checks the data it reads back, so a capacity fake can pass it; here the 256 MB test file also landed on the real first gigabyte, judging by the 39.7 MB/s write. Run the speed test to learn whether a genuine card is fast enough, and run f3 to learn whether it’s genuine.
How to check a new card before you trust it
Check every new card before you flash it, because the check destroys data and a card is never emptier than on day one. Fedora and Debian both package it as f3, so Raspberry Pi OS users can install it with apt. Debian 13 carries an older release than the one we ran. The order we’d follow:
- Probe the raw device: run f3probe with
--destructiveon the card’s device node fromlsblk, never on a disk you care about. - Or fill and verify: format the card, mount it and run f3write then f3read, which needs no root and also runs on macOS.
- Return a fake: f3fix can shrink the partition to the real size, but a card that lied about capacity has told you all you need to know about its flash.
The fill-and-verify route is slower because it writes the whole card, but it’s the one most readers can run from a laptop. On a genuine 2 GB volume the two commands look like this:
f3write /mnt/honest
f3read /mnt/honestA healthy card ends f3read with everything under Data OK and zero lost:
Data OK: 2.00 GB (4188288 sectors)
Data LOST: 0.00 Bytes (0 sectors)
Corrupted: 0.00 Bytes (0 sectors)
Slightly changed: 0.00 Bytes (0 sectors)
Overwritten: 0.00 Bytes (0 sectors)On the 8 GB fake the same two commands told a very different story. f3write reported writing files 2 through 6 at over 1 GB/s, which no microSD card can do. That speed is itself a giveaway, because the “writes” were going nowhere. We unmounted and remounted the card before f3read so the reads came from the device and not from cache, and the summary shows the real capacity to within a few megabytes:
Read the per-file lines as much as the totals. File 1 is almost entirely intact and every later file is entirely corrupted, which is the signature of a limbo fake: the card’s real size sits right at the boundary where good files stop. One more habit lowers the odds before any tool runs: buy from the listing sold by Amazon or the maker’s own store. While researching this guide, the cheapest results were third-party listings and unrelated brands, some sold with Raspberry Pi OS preinstalled. A card you cannot trace to its maker is the one most worth probing.
Where a microSD card stops being the right answer
A card is the right boot device for a Pi that mostly reads, and the wrong one for a Pi that writes hard and has to stay up. Raspberry Pi OS with a desktop asks for at least 32 GB (Lite for 8 GB), Home Assistant asks for 32 GB and ideally an A2 card, and both run happily on the picks above. The signs that you’ve outgrown the card are a recorder database you keep trimming, a k3s or Frigate node that writes constantly, or a second card failure on the same board.
At that point the fix is different hardware, not a better card. A Pi 5 can boot from an NVMe SSD on its PCIe connector, and the Raspberry Pi 5 kits guide covers the HATs that make that tidy.
If that connector is already earmarked for an AI accelerator on the Pi 5, it is worth reading how those boards share the single lane first. For Home Assistant alone, the Home Assistant Green ships with 32 GB of eMMC and keeps its microSD slot for recovery only. Our Home Assistant mini PC picks compare it with x86 boxes that boot from an SSD. If you are still choosing the board itself, the Pi 5 versus N150 comparison shows where a cheap mini PC with real storage starts to make more sense than a Pi with a very good card. For a Frigate NVR build, keep recordings off the boot card entirely, whichever board you choose.
