Buying used RAM on eBay: what's safe, and how to prove it

Yes, used RAM is safe to buy: a DRAM module has no moving parts and no consumable budget, so it is the one part of a used machine the previous owner could not have used up. What costs buyers money is three other things: a defect the module has carried since the factory, a module that is not what its label says, and a good module that will not run in the machine you own. Decode the part number and count the chips in the photograph before you buy, test in the first week while the return window is open, and on ECC memory read the error counters rather than the pass line, because a passing test hides a corrected hard fault.

Before you buy: the listing checklist

Nine checks, in the order they pay off. Each links to the part of this guide that explains it.

1. Filter before you judge any price. Generation, then form factor, then buffering, then capacity. Compare the row against the median printed at the top of that same filtered page, never against your sense of the market. Why the filtered median is the number to beat.
2. Read the part number, not the title. Decode it: device count, ECC status, word depth by bus width, buffering, speed grade. The organization and the capacity both fall out of it, and a title that contradicts it has told you which half is a guess. /en-us/part/ is the fastest route in, and decoding a part number shows how.
3. Count the packages in the photograph. Bus width divided by device width gives packages per rank; multiply by ranks. Nine per rank on DDR4 ECC, ten on DDR5 ECC, eight on non-ECC DDR4. Above about 64 GB the count stops tracking capacity, because of 3DS stacking.
4. Look at the contact edge and the package markings first. One wear band, gold intact, laser marking, one vendor, one date window, everything aligned to the same grid. Reading the listing photograph explains each one.
5. Check the machine before the module. Compatibility by server or by processor, what fits your machine, and RDIMM against UDIMM if there is any doubt. The most expensive mistake in used memory is not a dead module but a live one that will not POST in what you own.
6. Ask the seller two questions only: the full part number, and a photograph of the label on the actual module. A refusal from a seller with two hundred modules is a price rather than a verdict. What the seller can and cannot know explains why.
7. Start from the default listing view. Bid-only and for-parts rows are already excluded; A bid is not a price lists the switches that bring them back.
8. Book the test before the module arrives, so it runs inside the return window. The week it arrives gives the order.
9. Price a used module as an option rather than a purchase: the listing price plus shipping plus your test time plus the probability of a return. Buy where all four are survivable, and used memory is the cheapest reliable upgrade available to anybody. Lots and the arithmetic of a dud works one through.

The week it arrives: test, then decide

The return clock starts at delivery, so do this in the first week, not the fourth, and in this order.

0. Photograph the packaging before opening it, and the module before installing it, with the label’s serial legible. Both are free and both are evidence.

1. Inspect before you power anything. Contact edge, package markings, PCB around the notch and the corners, any flux residue. This is the last chance to find a problem that is unambiguously the seller’s.

2. Read the SPD before you trust the label. One machine, one module, decode-dimms, and compare every field against the listing photograph. The SPD is the tiebreaker has the commands.

3. Confirm the machine sees what you bought.

sudo dmidecode --type 17 | grep -E 'Locator|Size|Type|Speed|Rank|Part Number|Manufacturer'

Speed is the module’s rated speed and Configured Memory Speed is what the machine runs it at. Those two differing is normal: a 3200 RDIMM in a platform that tops out at 2666 runs at 2666, and two modules per channel derates further on most current platforms.

4. Test for long enough to be worth doing. A 16 GB desktop module is worth four passes. Sixteen RDIMMs going into a machine you will not want to take apart again are worth an overnight run with the retention test enabled, in the chassis, with the fans at their normal profile. Testing it on arrival covers which tester and which tests.

Then read the result against this table.

A non-zero correctable error count on a module you have owned for a week is not “ECC doing its job”. It is your return window doing its job. What one error is worth gives the numbers behind that rule, and the return path gives the deadlines.

What can actually be wrong with a used module

A DRAM cell is a capacitor and an access transistor, rewritten on a fixed refresh schedule because the charge leaks (CAS latency and timings covers refresh). Nothing in that loop consumes anything: no oxide worn by a tunneling current, as in flash, and no bearing or head, as in a hard drive. A cell that works has no mechanism by which running it for five years stops it working, so the list of faults is short and most of it was settled before the module was sold.

Five rows need a sentence more.

Variable retention time is why a quick test proves so little. Liu, Khan, Kim, Mutlu and others, testing 248 commodity DDR3 chips, documented cells whose retention time “changes unpredictably over time”: a cell holds its charge for seconds at one moment and sits in a leaky state minutes later. A test that writes and immediately reads cannot see such a cell, and a test that waits ninety seconds sees only the fastest of them. It is a property of commodity DRAM, not of used DRAM, and the best argument for a long test.

Post-package repair is the closest thing memory has to a consumable, and it is invisible. JESD79-4 added the ability to retire a failing row inside a finished DRAM device and substitute a spare, in a soft form that lasts until power off and a hard form that is permanent. The spares are few, fixed at manufacture, and the standard does not require a module to report how many remain. A module whose server applied a hard repair leaves the rack looking and testing exactly like one that has not. Neither you nor the seller can price this, which is a better reason to buy cheaply than the usual ones.

DDR5 moved voltage regulation onto the module. A DDR5 DIMM takes 5 V from a desktop or laptop slot, or 12 V from a server slot, and a power management IC on the module generates VDD, VDDQ and VPP locally. The 12 V figure gets quoted for all of DDR5 but belongs only to registered and load-reduced modules. The PMIC is an active switching part with a real failure rate, so on DDR5 a dead module is more likely dead from the module than from the dies, and a scorch mark next to the PMIC means something.

The register on an RDIMM does not raise your risk. The registering clock driver, specified by JEDEC in JESD82-31 for DDR4 and JESD82-511 for DDR5, latches and redrives the command and address bus; load-reduced modules add data buffers for the data lines. It has no wear mechanism, and as the largest chip in the middle of the module it is the easiest place in a photograph to spot scorching. What the register buys covers why the same module will not work in a desktop.

The SPD EEPROM is the only part somebody can change. Every other falsification needs heat, solder or a laser; rewriting the serial presence detect takes an I2C write and a few seconds. That asymmetry runs through the counterfeit checks.

What the fleet studies say, and how old they are

The fleet studies behind almost everything said about DRAM failure rates are old enough that their absolute numbers are history; their shapes are durable.

Schroeder, Pinheiro and Weber, on Google’s fleet across two and a half years, found more than 8 percent of DIMMs saw a correctable error in a year, and uncorrectable errors at 1.3 percent per machine per year and 0.22 percent per DIMM per year. They found “strong evidence that memory errors are dominated by hard errors”, the sentence that matters most to a used buyer: a hard error is a repeatable physical defect that was in the part before you bought it, and a test will find it.

Meza, Wu, Kumar and Mutlu, on Facebook’s fleet across fourteen months, found that the top 1 percent of servers accounted for over 97.8 percent of all correctable errors, and much of that came from failing memory sockets and channels, present on only 1.34 percent and 1.10 percent of servers with errors and yet dominating the counts. A module pulled out of “a server throwing memory errors” is frequently innocent; the motherboard was the patient.

Both studies predate DDR4 in the field. What survives is the structure: errors are hard rather than transient, they cluster, and the clustering is as much about the machine as the module.

No infant mortality, and who paid for it

Schroeder found no infant mortality at all in almost every population, because manufacturers burn modules in and weed out early failures before sale. Correctable error rates climbed after 10 to 18 months in the field, while uncorrectable incidence declined with age, because operators replace any DIMM that produces one. That survivorship favors the buyer: a decommissioned server pull was burned in, ran in controlled airflow under monitoring, and was retired on a refresh cycle. Its one bad property is that it is past the age at which correctable errors begin, and there is no odometer.

What one error is worth

Schroeder found that a DIMM which sees a correctable error is 13 to 228 times more likely to see another in the same month, across the fleet’s platforms. Correctable errors raise the odds of an uncorrectable error by a factor of 9 to 400: from 27 times on the best-behaved platform to more than 400 on the worst when the correctable error is in the same month, and 9 to 47 times when it was in the month before. Between 65 and 80 percent of uncorrectable errors were preceded by a correctable error in the same month, and 70 to 80 percent by one in that month or the month before. Meza found the same shape: errors per server follow a Pareto distribution with a decreasing hazard rate, so the more errors a machine has produced, the more it should be expected to produce.

The odometer that does not exist

A used drive hands you a lifetime log, and the problem is deciding whether to believe it. A used module hands you nothing: there is no field to forge because there is no field.

Three fields, all about origin and none about use, which is why buying used memory is mostly reading a photograph rather than a log.

Hours are not the risk; thermal cycles are. No wear mechanism accumulates with powered hours. Solder fatigue accumulates with thermal cycling, as the package, the solder ball and the PCB expand at different rates. Under the standard Coffin-Manson model, where damage scales roughly with the number of cycles times the square of the temperature swing, and with assumed inputs of two power cycles a day and a 25 °C swing for a desktop against one cycle a quarter and a 5 °C swing for a server, four years give the desktop module about 4,560 times the solder damage. The inputs are assumptions chosen to show the shape, and the market prices “ran for six years in a server” backwards. The real risk in a decommissioned module is the two weeks after it leaves the rack: pulled quickly, dropped into a tray, possibly stacked or wrapped in ordinary bubble wrap, and shipped. That is what the listing photograph can tell you most about.

Heat is the design point, not evidence of abuse. JESD79-4’s normal operating range runs to 85 °C case temperature, with an extended range above that in which the refresh rate doubles. Running at 80 °C for five years leaves no mark, so general discoloration proves nothing. Localized damage does: a scorch mark beside the registering clock driver, a discolored ring around a DDR5 PMIC, a lifted pad, a darkened area under one package and not its neighbors.

Reading the label and decoding the part number

Almost every field on a memory label is checkable, and most used-market fraud survives because buyers read the capacity and the speed and stop.

The PC-code and the data rate are the same fact. The PC number is peak bandwidth in megabytes per second for a 64-bit module, eight times the data rate: PC4-25600 is DDR4-3200, PC3-12800 is DDR3-1600, PC5-38400 is DDR5-4800. The generation digit after “PC” is the fastest way to catch a title that says DDR4 over a photograph of a PC3 label. Megahertz against mega-transfers covers the rest of the speed notation.

The letter after the dash decides whether it runs in your machine. Newer DDR4 labels write the data rate directly instead, as in PC4-2666V, which is DDR4-2666. In PC4-2666V-RD1-11 the letter after the speed is a latency bin code, not a revision, and the letter after the dash is the module type: U for unbuffered, E for unbuffered with ECC, R for registered, L for load-reduced. Treat the rest of the tail as a vendor field and go to the part number for anything that matters. RDIMM, UDIMM and LRDIMM explains what each letter costs you if you get it wrong.

The organization code fixes the chip count, and the chip count is checkable

2Rx8 means two ranks, each built from devices eight bits wide. That, plus the bus width, settles how many DRAM packages must be visible in the photograph, and it is the cheapest counterfeit check there is. For DDR4 the module bus is 64 bits without ECC and 72 with it:

2Rx4, 32 GB, ECC DDR4 (72-bit bus)
  devices per rank   72 bits ÷ 4 bits per device       = 18
  devices on board   18 × 2 ranks                      = 36
  of those, data     32 carry data, 4 carry ECC
  die density        32 GB × 8 bits ÷ 32 data devices  = 8 Gbit

1Rx8, 16 GB, non-ECC DDR4 (64-bit bus)
  devices per rank   64 ÷ 8                            = 8
  devices on board   8 × 1 rank                        = 8
  die density        16 GB × 8 ÷ 8                     = 16 Gbit

If a label says 2Rx4 32 GB and the photograph shows eighteen packages on one side with nothing on the back, the label is wrong. Count them.

A DDR5 module is two independent 32-bit subchannels, each with its own 8 bits of ECC on an ECC part, so the module bus is 80 bits wide rather than 72, and a lot of advice in circulation has not caught up:

DDR5 ECC module: 2 × (32 data + 8 ECC)                 = 80 bits

  1Rx4   80 ÷ 4 = 20 packages        1Rx8   80 ÷ 8 = 10 packages
  2Rx4   40 packages                 2Rx8   20 packages

2Rx8 DDR5 RDIMM built from 16 Gbit dies
  total silicon      20 × 16 Gbit = 320 Gbit           = 40 GB
  data portion       320 × 64 ÷ 80 = 256 Gbit          = 32 GB

Ten packages per rank on a DDR5 ECC module against nine on DDR4, and a seller who has relabeled a DDR4 card cannot fix the count. The exception is 3DS, where two to eight dies stack inside one package, so above roughly 64 GB the visible count stops tracking capacity. Ranks and 3DS modules works through that case.

A vendor part number encodes the module, and you can decode it

This is the most useful skill in buying used memory. Micron’s DDR4 module scheme states the device count, the ECC status, the word depth, the bus width, the buffering and the speed grade, in that order, and the organization falls out of the arithmetic:

MTA18ASF2G72PDZ-2G6E1

  MTA       Micron module
  18        eighteen DRAM packages on the module
  ASF       DDR4, with ECC   (ATF is DDR4 without ECC)
  2G72      2 G words × 72 bits
  PDZ       registered
  2G6       2,666 MT/s
  E1        component revision

derived organization
  bus width                    72 bits
  devices per rank   18 ÷ 2            = 9         (so two ranks)
  device width       72 ÷ 9            = 8 bits    -> 2Rx8
derived capacity
  data bits          2 × 2^30 × 64                 = 137.4 Gbit
  in bytes           137.4e9 ÷ 8                   = 17.18e9 B = 16 GB

The organization and the capacity are both derivable from the part number alone, so a listing whose stated capacity contradicts its stated part number has told you which of the two is a guess. The decode follows Micron’s published module numbering, and this site’s page for the family is MTA18ASF2G72PDZ-2G6. Samsung’s module prefixes settle module type before you read anything else:

SK hynix uses HMA for DDR4 modules and HMC for DDR5. All three vendors publish decoders; use the vendor’s, not a forum post, because the schemes change between generations and a DDR3 decoder produces confident nonsense on a DDR4 part. This site keeps a page per part number it has seen, at /en-us/part/, the fastest way to find out whether a code is a part number at all or a machine name somebody typed into a title.

Date codes, and what two of them disagreeing means

The SPD manufacturing date is written by the module assembler, and decode-dimms prints it as 2018-W23. The package date codes are laser-etched on the DRAM, usually as a year and week, and should sit a few weeks to a few months earlier, because the dies were made first. All packages within a few weeks of each other is a normal build. Packages whose dates are far apart mean a rebuild from harvested parts: not automatically fraud, but not a factory module either. A pristine label claiming a recent build over packages dated years earlier, or an SPD date that contradicts the label, is settled. Relabeling the outside takes a printer; rewriting the SPD takes an I2C write most relabelers do not bother with, which is why you read it on arrival even when the photograph looked fine.

Reading the listing photograph

A stock image on a used listing is a reason to move on, and on a single-module listing it is close to conclusive: a seller with one module and a phone has no reason to use a catalog render. On a lot of forty, “one representative photograph plus the tray” is what a working recycler does. When there is a real photograph, here is what to read.

A memory module has no pins

It has plated contacts on the edge of the PCB. “Bent pins” on a memory listing means the seller photographed a socket, so either the item is different or the seller does not know what they are selling. What matters on the contact edge is plating wear: the contacts are thin gold over nickel over copper, and once the gold is scraped through, the base metal oxidizes and fretting corrosion builds a resistive layer where you need none. DIMM socket datasheets rate mating cycles in the tens rather than the hundreds.

One clean wear band, a matte stripe at the depth the socket grips, is normal. Two bands at different depths means the module has been in two different socket designs. Scratches running along the contacts mean somebody dragged it. Clean contacts with isopropyl alcohol and a lint-free cloth, never a pencil eraser, which removes gold plating measured in fractions of a micron.

Package-level tells

The counterfeit-electronics inspection standards, SAE AS6081 and IDEA-STD-1010, both start with external visual examination: marking permanence, surface texture, package dimensions, ball condition and consistency across a batch. Most of that works on a photograph.

Modern DRAM from the three big vendors is laser marked: the marking is cut into the surface and catches the light differently from the plastic around it, where ink sits flat on top. An ink marking on a package that should be laser marked is the strongest remarking tell a photograph can show. In hand, a marking that a mild solvent lifts was not applied by the manufacturer. A resurfaced package, sanded and coated to hide the original marking, shows a too-uniform surface, softened corners, a missing or shallow pin-1 dimple, or a different gloss from its neighbors.

Then the free batch check. Every package on an honest module comes from one vendor, one part number and a narrow date window, aligned to the same grid. One package with a different font, a different height or flux around it has been replaced, sometimes as a legitimate repair and sometimes as a dead die swapped from a scrap board, and you cannot tell which from outside.

Packaging and heat spreaders

Modules ship in antistatic trays and bags because DRAM is ESD-sensitive (ANSI/ESDA/JEDEC JS-001). Catastrophic ESD damage is immediate and a test will find it. Latent ESD damage is real and unfalsifiable, so a padded mailer is not proof of damage. It is a proxy for the seller: one who ships memory in an antistatic bag inside a rigid box knows what they are handling, and one who mails four bare modules stacked in an envelope is telling you how much care went into the word “tested”.

Enthusiast desktop memory usually sits under an aluminum heat spreader that hides the package count, the markings and the date codes in one move. Its XMP or EXPO profile can be verified in the SPD after arrival, but the part number on the label is doing all the work, and a listing without one is worth materially less. On DDR5 desktop memory almost everything has a spreader; on server memory almost nothing does, one reason server pulls are easier to buy safely than enthusiast kits.

Counterfeits, relabels and modules with no DRAM in them

Three different things get called counterfeit memory. Relabeled genuine modules are real DRAM under a label claiming more capacity, more speed, a different rank structure or a different brand; this is by far the most common, and the chip count is the defense. Remarked packages are dies, often recovered from scrap boards, with their markings sanded off and replaced; the package-level tells are the defense and the SPD is the tiebreaker.

Modules containing no DRAM at all are not a myth. Corsair sells light enhancement kits, which it describes plainly as “dummy RAM modules” with “no actual RAM chips inside”, to fill empty slots for appearance, and warns that “unscrupulous sellers on the internet are passing off LEKs as actual RAM modules”. A real DDR4 or DDR5 DIMM has 288 contacts; a light kit has, in Corsair’s words, “noticeable gaps along the bottom edge”.

The SPD is the tiebreaker, and what its CRCs do not cover

The SPD is written at build time and is harder to fake convincingly than a label, because it has to be internally consistent.

sudo modprobe ee1004            # DDR4 SPD, page-switched 512-byte EEPROM
sudo modprobe spd5118           # DDR5 SPD hub
sudo decode-dimms | grep -E 'Manufacturer|Part Number|Manufacturing Date|Size|Rank|Width'

decode-dimms is part of i2c-tools and implements JEDEC’s JESD21-C SPD annexes. On DDR4 the SPD is a 512-byte EEPROM reached through a page-select protocol, which is what the ee1004 driver is for; on DDR5 it sits behind an SPD hub that also carries a temperature sensor, served by the mainline spd5118 driver.

One detail changes how much to trust what you read. On DDR4, the manufacturer block, holding the vendor ID, the manufacturing date, the serial number, the part number string and the DRAM vendor ID, sits in the 320 to 383 byte region, and neither of the SPD’s two CRCs covers it. An edited part number will not produce a CRC failure; an edited timing table might. So the check is not “does the SPD parse” but “does it agree with the physical module”:

Three independent sources for every claim. A relabeler fixes one. Somebody reprogramming the SPD fixes two. Fixing all three means replacing the packages, which is building a module rather than faking one. SPD vendor IDs are JEDEC JEP106 codes, and one that decodes to a company that does not make modules, or to an unassigned code, was written by hand.

Decoding the packages themselves

Micron publishes an FBGA decoder: enter the five-digit code from the package into the FBGA Code field and it returns the full part number. Samsung and SK hynix publish their own package numbering, with the same structure of vendor prefix, density and organization, die revision and speed grade. Check that the decoded density times the package count produces the claimed capacity, and that the decoded speed grade is at least what the label claims, because a module cannot be faster than its slowest die.

What a speed relabel actually does

A relabeler who edits the SPD timing table to claim a higher bin is asking dies binned slower to meet tighter timings. Sometimes that works at room temperature and fails at 70 °C in a loaded server weeks later, looking like a random crash. A short memtest run at an open bench is the test least likely to reproduce it, which is why you test warm, in the chassis. On enthusiast memory the same trick is an XMP or EXPO profile edited upward, and the machine usually refuses to train, which is a better failure.

What the seller can and cannot know

Almost every dispute about used memory comes from buyer and seller meaning different things by “tested”. A seller can know cheaply what the label says, what machine the module came from, whether it POSTed, and what a bench DIMM tester said in sixty seconds. A full multi-pass test costs hours per module and will not happen on a pallet of four hundred. No seller can know at any price the module’s correctable error history, which lived in the host, how many repair elements are spent, whether it has variable-retention cells, or whether the socket rather than the module caused the errors that retired the machine.

The vocabulary, translated

“Untested” is frequently the more honest listing, and it should be priced lower rather than avoided: you are buying the module at a discount, plus your own test, plus a return path. That is a good trade when the discount is larger than the friction.

Most cheap server memory passes through IT asset disposition. R2v3, run by SERI, and e-Stewards are the two recognized certifications, and both require documented processes for data sanitization and for testing and grading what gets resold, so a seller who names one has made a checkable claim. The rest of the trade is a recycler with a pallet and a bench tester that reads the SPD, verifies the organization and runs a quick pattern test. What it cannot do is wait, so it has not looked for retention faults.

Condition codes, and the one that removes your claim

eBay’s condition is a structured numeric field, and this site shows the code rather than the seller’s wording, which is why a listing titled “working pull” can still display as for parts.

3000 is the code that catches people: eBay defines used as fully operational and functioning as intended, and a memory module meets that bar by appearing in the POST count. 7000 is a disclosure that defeats a not-as-described claim, because a module listed for parts that arrives dead has arrived as described. This site hides for-parts rows by default, since a module with no usable gigabytes would otherwise take the cheapest positions on every page; ?parts=show brings them back. The four eBay Refurbished grades are gated: sellers are vetted before they can use them, and that vetting, not the adjective, is the difference between 2010 and 2500.

Testing it on arrival

A test is worth what its fault model is worth. The classical march tests walk the address space with a fixed sequence of reads and writes, designed against this model:

March C-, the standard reference algorithm, is ten operations per cell and detects the first four classes. It cannot detect the fifth, because there is no waiting in it, and the fifth is the one used-market advice is supposed to be about.

The arithmetic says under a minute; a real test takes hours, and the gap is the point. On 256 GB of DDR4-2666 across six channels, each of March C-’s ten operations touches every cell once, about four seconds each at half of peak bandwidth, so the whole algorithm takes roughly forty seconds. PassMark’s own example timings for MemTest86 are 15 minutes for one pass and 120 minutes for its default four, with no configuration stated. The difference is where the useful tests live: random patterns that defeat the prefetchers, and retention tests that deliberately wait.

The two testers, and which limits matter

Both boot from USB under UEFI. On a two-socket server pull, the free edition’s 16-core cap is the limit that bites: it turns a bandwidth-bound test into a core-bound one and multiplies the time of every pass.

Which tests matter

The retention test is the one you came for. It writes a pattern, sleeps, and re-reads, which is why it has often been off by default or truncated; older MemTest86 builds shipped a bit-fade test with a ninety-minute sleep, off by default. Given cells that change their retention behavior over hours, ninety minutes is a floor and not a reassurance.

The row-hammer test tells you less than its name suggests. Since v6.2 MemTest86 runs up to two passes: one at the maximum achievable rate and, if that errors, one at 200,000 accesses per 64 milliseconds, the rate vendors treat as a worst case. If only the first pass errors you get a warning, not an error, and it is not grounds for a return: no part is specified to survive the fastest hammering a controller can produce. Row-hammer exposure belongs to the part and its date, not its use. Kim and colleagues found disturbance errors in 110 of 129 DDR3 modules tested, concentrated in parts made from 2010 onward, and JESD79-5 now defines refresh management for DDR5.

The address and moving-inversions tests find real hard faults, and they finish quickly, which is why one pass is genuinely useful and four are much better.

How many passes, and what a pass is worth

If a fault has probability p of showing on any one pass, the chance of still not having seen it after n passes is (1 - p)^n. The probabilities below are assumptions; nobody can tell you the real ones.

p = 0.50   4 passes  6.3 %      10 passes  0.10 %
p = 0.20   4 passes  41  %      10 passes  10.7 %
p = 0.05   4 passes  81  %      10 passes  59.9 %

A stuck cell has p close to 1. A variable-retention cell may have a p of a few percent per pass, and the bottom row is what that costs: four passes on a module with a VRT cell is four fifths likely to tell you the module is fine.

Isolating a failure before concluding anything

A slot fault and a module fault look identical in a report, and the free edition will not name the module. PassMark’s guidance: if the failing addresses are few and only one or two bits are in error, the errors are real, and moving a module between slots “can clean up dirty or corroded contacts”. So reseat, re-test, move slots, re-test, and only then test modules one at a time. On a lot, bisect: sixteen modules take four runs to isolate one fault, against up to sixteen one at a time, the difference between an evening and a week.

Testing under the operating system

memtester runs the classical patterns from inside the operating system but can only test memory it can allocate. stressapptest, written at Google to qualify hardware, drives randomized traffic from the processor and I/O at once, producing the heat and power load a march test never does, which suits a module that is fine on an open bench and marginal under load. Run it for hours with ECC reporting on, and watch the counters rather than the exit code.

ECC changes the test completely

On an ECC module, a single-bit hard fault is corrected before the data reaches the processor. The test writes a value, the controller corrects the failing bit on the way back, and the test receives exactly what it wrote and reports a pass. The defect is real and permanent, and the only place it appears is a counter the test is not looking at. On ECC memory the counters are the result.

sudo systemctl enable --now rasdaemon
ras-mc-ctl --error-count      # corrected and uncorrected counts per DIMM
ras-mc-ctl --summary          # the logged errors, grouped by DIMM label
ras-mc-ctl --errors           # the individual events with timestamps

rasdaemon reads the kernel’s EDAC subsystem. Its per-DIMM labels come from the system’s SMBIOS tables, so check the label mapping against physical reality once, against dmidecode --type 17, before you trust a report that names a slot. Then take two captures: the counters right after first boot, and again after the load. A count already non-zero at first boot tells you about the firmware, not your module.

The three ways ECC errors get hidden from you

Firmware-first handling. On many platforms the firmware sees the machine check first. On AMD platforms the setting usually named Platform First Error Handling can stop ECC errors reaching the tester or the OS at all. MemTest86 polls the chipset’s ECC registers directly, including in the free edition, though PassMark says the detail available “depends heavily on the CPU/memory controller chipset”.

Memory RAS modes. Mirroring, rank sparing and similar features exist to mask failures. Turn them off while testing a purchase.

On-die ECC. JESD79-5 requires DDR5 devices to correct errors inside the die, invisibly to the host, on modules with no ECC bits on the bus. So a DDR5 non-ECC UDIMM with a single failing cell can pass any host-side test you run, failing only when a second error lands in the same codeword, where the same defect on a DDR4 non-ECC module fails a march test in the first pass. On DDR5 the cheap, sure test is quietly less conclusive. On-die ECC is not ECC in the sense that matters, though listings call DDR5 UDIMMs ECC on the strength of it; ECC versus non-ECC covers the difference, and real ECC is the ECC facet on the listing pages, not a word in a title.

DDR5 gives a little back. JESD79-5 defines Error Check and Scrub, a background scrub inside the device with provision for reporting error counts through mode registers, if the platform exposes them. And the SPD hub’s temperature sensor reports now, not history. There is still no odometer.

Price per gigabyte, read against this market

A used module has no list price worth comparing against, so compare it with the same kind of module on the same market on the same day. Price per gigabyte here is total delivered cost over total capacity: item price plus shipping, divided by every gigabyte the listing includes, so a kit of two 16 GB modules is 32 GB. The column is left blank whenever either half is unknown, because a figure built on a missing shipping cost would sort straight to the top. The methodology page covers how listings are read; eBay’s search interface returns no part number field, so every part number here is recovered from the title.

Compare a row against the median of its own filtered set

Every generation page prints the cheapest Buy It Now price per gigabyte and the median in the same sentence, and the ratio between them is the thing to read. Which way the typical gigabyte of each generation has been moving is on Trends. A row a factor of two under the median of its own filtered set is usually a genuine bargain, a generation nobody wants, or a lot. A row an order of magnitude under it is essentially never a bargain, and almost always one of the patterns below.

Filter first. A 64 GB LRDIMM against the median of all DDR4 tells you nothing, because 8 and 16 GB modules dominate that median; filter to DDR4 32 GB or DDR4 server memory and the comparison is the right one.

The patterns that mean something is wrong

These shapes come from past captures of this site’s catalog.

Registered DDR4 at a fifth of the going rate is often Intel Optane. Optane persistent memory shipped as a DDR4 DIMM and is listed under eBay’s memory category, so every structured signal reads DDR4 RDIMM, but it is not DRAM, runs only on the Xeon generation it was built for, and is discontinued. In one capture, eighteen Optane listings sat at 0.59 to 1.46 per gigabyte against a DRAM median of 5.25, and took the cheapest slots on every DDR4 page until they were excluded.

Quantity is not capacity. “10x 8gb DDR5 SK Hynix 4800 & 3x SK Hynix 5600” means the seller has ten and the price buys one; read as a kit, it produced 1.28 per gigabyte. A title formatted as * Lot of 8 * 64GB 8x8GB * became a 512 GB lot at 0.089 per gigabyte.

An organization code is not kit notation. “128MB MEMORY 16X64 168 PIN PC66” is a 128 MB module organized as 16 million words by 64 bits. Multiplied out as a kit, it became a 1,024 GB listing at 0.0127 per gigabyte.

A missing price per gigabyte is a missing shipping cost, usually one eBay calculates from a buyer location this site does not send, not a free listing.

Cheap because of where it ships from is not cheap. Every row shows the ship-from country. A module at $4.00 per gigabyte from another continent, with duty, a three-week transit and a return that costs more than the module, is not the same purchase as one at $5.50 from your own country.

The outlier that is real

Registered ECC memory one generation behind current is retired from data centers on fixed refresh cycles in enormous quantity, and almost nobody outside a server can use it. Its low price signals a small market, people who own a board that takes registered memory, a retired Dell PowerEdge R730 or HPE ProLiant DL380 Gen9 for instance, fed by waves of thousands of modules whenever a fleet is retired. DDR3 server memory is cheaper still, and the trap there is what the machine costs to run.

The running cost decides DDR3 against DDR4. Dynamic power scales with voltage squared, and supply voltage fell every generation: 1.8 V for DDR2, 1.5 V for DDR3 (1.35 V for DDR3L), 1.2 V for DDR4, 1.1 V for DDR5. (1.5 ÷ 1.2)² is 1.56, so 56 percent more dynamic power per transition for DDR3 than DDR4, before the extra modules a DDR3 machine needs. Assume a conservative 2 W of difference per module: sixteen modules is 32 W, 280 kWh a year running continuously, and $70 a year at $0.25 per kWh, before cooling. A DDR3 set $200 cheaper than the DDR4 equivalent pays that back in under three years of continuous running. For a machine that runs occasionally, buy the cheap generation; for one that runs continuously, do this sum first. The same arithmetic is why DDR2 and DDR sell as spares for machines that already exist.

Slots run out before the budget does. Price per gigabyte ranks modules, not machines: the cheapest gigabyte often means modules too small for the capacity you want, and most platforms derate when the second slot in each channel is filled. On an eight-channel fifth generation Xeon Scalable platform with a Platinum 8 processor, Cisco’s and Supermicro’s figures give 5,600 MT/s at one module per channel and 4,400 MT/s at two, so 512 GB from sixteen 32 GB modules has 21 percent less peak bandwidth than from eight 64 GB modules, and no free slots. Server memory capacity limits has the full matrix.

A bid is not a price

An auction’s current bid is a lower bound with time left on it, so a page sorted cheapest first would open on listings nobody can buy at the price shown. Since September 18, 2026, this site excludes bid-only listings by default, as the drives site does. The controls beside every table bring things back:

• ?bids=show returns listings whose only price is a bid, marked as bids.
• ?auctions=no removes every auction, including ones that also carry a Buy It Now price.
• ?parts=show returns modules eBay marks for parts or not working.

An auction that also carries Buy It Now has stated a price somebody can pay today, so it stays in the default comparison. Auctions are still worth reading, because a tray of RDIMMs from somebody clearing a garage looks like scrap to most watchers. Read the auctions; price against the Buy It Now distribution. Best Offer suits memory too: a volume seller with two hundred identical modules wants inventory moving, and a polite offer on a listing that has sat for a month is frequently accepted.

When it fails: the return path

Opening the request. For an item not as described, eBay’s Money Back Guarantee gives you 30 calendar days after the estimated or actual delivery date, or the seller’s stated returns window, whichever is longer, so a 60-day return policy is a 60-day not-as-described window.

Escalating it. You may ask eBay to step in no earlier than 3 business days after opening the request and no later than 21 business days after it. Miss the ceiling and the case closes in the seller’s favor, however good your evidence. Put it in your calendar the day you open the case.

What counts. A buyer is entitled to a refund where the item arrives broken, damaged or faulty and was not clearly described as such, or is not the item described. A “no returns” listing does not remove that right, and the seller pays return shipping when that is the reason. Change of mind falls under the seller’s own policy.

Testing is free. Buyers must return an item in the condition it was received, except where use was necessary to determine its quality or functioning. For a used hard drive that clause matters, because proving capacity means erasing it. For memory it barely matters: every test in this guide is non-destructive.

Keep the evidence. Photograph the failure rather than describing it: a tester’s error screen with the failing address and bit pattern, or ras-mc-ctl --error-count output with the DIMM label visible. Keep the listing photograph, your arrival photographs and both counter captures. Message the seller first; a volume seller will usually replace a module without argument, because the replacement costs less than the case.

Lots, and the arithmetic of a dud

Lots are where the good prices are and where one dead module moves the effective price more than any negotiation will.

lot of 16 × 16 GB RDIMMs, delivered 1,400 USD
  claimed        16 × 16 = 256 GB      1,400 ÷ 256  =  5.47 USD/GB
  one dead       15 × 16 = 240 GB      1,400 ÷ 240  =  5.83   (+7 percent)
  two dead       14 × 16 = 224 GB      1,400 ÷ 224  =  6.25   (+14 percent)
  four dead      12 × 16 = 192 GB      1,400 ÷ 192  =  7.29   (+33 percent)

Every failure costs more than the last one, because the denominator shrinks while the numerator does not. Find the two duds inside the window and you paid $5.47 per gigabyte for what arrived good, because the seller refunds or replaces them; find them in week five and you paid $6.25.

Nobody can tell you honestly what yield to assume. Schroeder’s annual correctable-error incidence above 8 percent came from a monitored fleet that had already had its bad modules removed; an untested recycler pull has not. Buy lots at a price where one dud is an annoyance rather than a dispute. Memory has one advantage over drives here: a lot of eight 14 TB drives is a week of serial testing against a thirty-day window, while sixteen RDIMMs go into one two-socket board at once and answer the first question overnight.

A six-year-old registered module out of a retired fleet, with a part number that decodes to exactly what the label claims, nine packages per rank from one vendor in one date window, an unworn contact edge, and a clean correctable-error count after an overnight run, is a better purchase than a two-year-old desktop module of unknown provenance under a heat spreader that hides every check in this guide. That trade is only visible if you read the part number, and only safe if you test before the window shuts.