DeviceBenchFree online dead pixel checker
Dead pixel checker that tells the three faults apart
Five flat fields run in a fixed order — red, green, blue, white, then black — and each one exposes a fault the others hide: a dark dot on a primary is one subpixel that has stopped lighting, a dark dot on white is a pixel with nothing driving it at all, and a dot that still glows on black is stuck rather than dead. Space advances, the arrow keys go back, and a tap drops a gray ring on the suspect spot so you can find it again on every remaining field. Your panel’s pixel count is read from the browser and turned into the number of faults ISO 9241-307 class II actually tolerates — about sixteen bright dots on a 4K screen, which is usually the sentence a support desk quotes back at you.
- 100% free
- No signup
- 5 fields
- Marker ring
- ISO fault classes
Reading the display…
Waiting for the display figures…
| Red | A dark dot is a red subpixel that has stopped lighting. It is nearly invisible on a white field. | — |
|---|---|---|
| Green | Green carries about 71% of what your eye reads as brightness, so a failed green subpixel is the one that shows up in ordinary use. | — |
| Blue | Blue is the dimmest of the three and the easiest field to search — a dead blue subpixel leaves a dot that looks almost black. | — |
| White | All three subpixels at full. A black dot here is a dead pixel: no transistor, no light, on any image. | — |
| Black | Everything off. Any dot that still glows is stuck or hot, and stuck is the only kind that sometimes comes back. | — |
Nothing judged yet. Each field gets a verdict from the bar at the bottom of the screen.
A page cannot take over the display in this browser, which is the rule on iOS rather than a preference. The walk still runs edge to edge inside the page, but the rows of pixels under the address bar are not tested — rotate the phone and repeat if the suspect area hides there.
The unstick loop drives one 180-pixel square through eight colors at your panel’s frame rate. Choose how long it runs, drop the ring on the suspect pixel inside the field, then start it from the bar — it is a flashing pattern and will not begin on its own.
How to check a screen for dead and stuck pixels
Three passes: find it, identify it, and only then try to fix it.
Walk the five fields with the space bar
Sit about 30 cm from the glass and sweep the panel in horizontal bands rather than staring at the middle — a single fault is a fifth of a millimeter across on a 4K monitor and peripheral vision will not catch it. Space moves to the next field and the left arrow goes back, so the whole walk happens without looking away. Give each field a verdict from the bar before you move on; the results table on this page fills in as you go.
Ring anything suspicious and check it on the other fields
Tap the spot to drop a gray ring on it. The ring survives every change of color, which turns one glance into a diagnosis: a dark dot that shows on white and disappears on black is dust sitting on the glass, a dark dot that shows on white and on all three primaries is a pixel with nothing driving it, and a dot that glows on the black field is stuck or hot rather than dead.
Try the loop on a stuck pixel, and know when it has failed
With the ring in place, start the eight-color loop from the bar and leave it for the ten minutes it defaults to. It drives that one square through its full voltage range, which occasionally frees a cell that has jammed; it does nothing at all for a pixel whose transistor is gone, and if twenty minutes has not moved it, more time will not either.
Technical specifications
| Fields and order | #FF0000, #00FF00, #0000FF, #FFFFFF, #000000 — the three primaries first, while your eyes are still fresh |
|---|---|
| Why no cyan, magenta or yellow | A secondary is two primaries lit together, so every subpixel fault it could reveal is already visible on one of the three primary fields |
| Keyboard | Space, → or Page Down for the next field, ← or Page Up to go back, 1–5 to jump, H to hide the bar, Esc to leave |
| Marker | A 28 px gray ring, never a dot, so it cannot be confused with the fault; position reported in CSS pixels and device pixels |
| Magnification | None, and no web page can honestly offer it — a browser cannot read the panel, so anything it enlarged would be the flat fill it drew itself |
| Unstick loop | One 180 px square cycling eight colors at the panel's own frame rate, for 1, 5, 10 or 20 minutes, started only by a click |
| Fault allowance shown | ISO 9241-307 class II — 2 always-bright, 2 always-dark and 5 faulty subpixels per million pixels, scaled to your resolution |
| Hidden tab | The loop stops itself, because a background tab is throttled to roughly 1 frame per second and would flash almost nothing |
Frequently asked questions
What is the difference between a dead pixel and a stuck one?
A dead pixel has lost the transistor that drives it and a stuck pixel is being driven to the wrong value, which is why one is permanent and the other sometimes is not. Dead means the cell has fallen back to its rest state and stays there through every image, on most modern panels showing as a dot that is black on white and black on red, green and blue alike. Stuck means one subpixel is held at full output, so the dot reads red, green, blue, or a mix such as cyan or yellow, and it is visible on the black field where a dead pixel is invisible. A pixel with all three subpixels stuck on is usually called hot, and it shows as a white speck on black.
Can a stuck pixel actually be fixed?
Sometimes, and the odds are worse than the internet suggests. Rapid color cycling — what the loop on this page does — repeatedly drives the cell through its whole voltage range and can free a crystal that has jammed; ten minutes is a reasonable attempt and twenty is generous. The other folk method, rubbing the spot with a cloth over a switched-off screen, works occasionally and risks pressure marks, cracked polarizer film and, on a laptop, a hinge under load it was never designed for. Neither does anything for a dead pixel, because there is no signal reaching the cell to be unjammed.
How many bad pixels before a manufacturer replaces the screen?
More than most people expect, and the numbers come from ISO 9241-307, which nearly every maker ships class II against. Class II permits 2 always-bright pixels, 2 always-dark pixels and 5 faulty subpixels for every million pixels on the panel — so a 1920 × 1080 monitor has 2.07 million pixels and is allowed roughly four bright, four dark and ten subpixel faults, while a 3840 × 2160 panel is allowed about sixteen, sixteen and forty-one. That is the arithmetic a support desk is quoting when it declines a return for a single dot. Class I permits none at all and is sold separately, usually as a zero-bright-dot guarantee on professional lines.
The dot is on the white field but gone on the black one. Is it a pixel?
That combination is dirt, not a pixel. Anything sitting on the outside of the glass blocks light, so it darkens a bright field and vanishes against black where there was no light to block. A genuine dead pixel behaves the same way at first glance but stays dark on the red, green and blue fields too, and dirt usually has a soft edge and an irregular shape while a pixel fault is a hard-edged rectangle. Wipe the spot before you spend twenty minutes on the loop.
A dot only appears when something is moving. What is that?
That is not a pixel fault, because these fields are completely static and a fault visible on them is visible whether anything moves or not. What you are seeing is pixel response: the crystal taking too long to reach its new value, which leaves a trail behind moving objects and sometimes a bright overshoot in front of them. A related and equally common cause is a panel that is not running at the refresh rate you paid for, which the refresh rate test settles in a few seconds by counting the frames actually delivered.
How close do I need to be to see one?
Close enough that a single pixel is bigger than the limit of your vision, which on a modern monitor means about 30 cm. A 27-inch 4K panel runs at 163 pixels per inch, so one pixel is 0.156 mm across and one subpixel is a third of that; the same 27-inch screen at 1440p has 109 ppi and pixels of 0.233 mm, which is why faults are noticeably easier to find on a lower-resolution screen of the same size. Work out the figure for your own panel with the ppi calculator if you want to know what you are hunting before you start.
Is the flashing loop safe to watch?
Do not sit and watch it, and do not run it at all if you or anyone in the room has photosensitive epilepsy — roughly one person in four thousand does, and the frequencies between 15 and 25 flashes per second are the most provocative. The loop changes color every frame inside one 180-pixel square, which is why it is confined to a small area, why it starts only from a deliberate click, and why nothing on this page flashes until you ask for it. Start it, look away, and come back when the timer has run out.
About pixel faults and the standard that decides who pays
One pixel on a color LCD is three cells side by side, red, green and blue, each with its own thin-film transistor holding a voltage across a sliver of liquid crystal. A fault is almost always one transistor rather than one pixel, which is why the useful vocabulary is finer than “dead”. When the transistor stops driving its cell, the cell falls back to whatever state it rests in with no voltage applied — and that rest state is a design decision, not a constant. Most modern IPS panels rest dark, so a failed cell shows as a black dot; the older normally-white designs rest transmitting, so the same failure shows as a bright dot. That is precisely why the standard counts always-bright and always-dark faults in separate columns, and why “dead pixel” is a misleading name for half the cases. A stuck pixel is the opposite situation: the transistor still works and is holding the cell at full output, so the dot has a color — red, green or blue for one subpixel, cyan, magenta or yellow for two, white for all three. Only the stuck kind ever comes back, because only the stuck kind is still receiving a signal.
The document behind every warranty argument is ISO 9241-307, which took over from ISO 13406-2 in 2008 and sorts panels into classes 0 through IV by how many faults per million pixels they may carry. Class II is what almost every consumer monitor, laptop and television is built to: 2 always-bright pixels, 2 always-dark pixels and 5 faulty subpixels per million, with separate and much tighter limits on clusters of faults in a 5 × 5 block. Scale that to real panels and the consequence is stark. A 1920 × 1080 screen holds 2.07 million pixels, so four bright dots and four dark ones are inside spec; a 3840 × 2160 screen holds 8.29 million, and the allowance grows to roughly sixteen of each plus forty-one faulty subpixels. Class I permits none of any kind, which is what a zero-bright-dot guarantee is selling, and class 0 exists mainly on paper. If you want the exact pixel count for the arithmetic on your own display, the screen resolution page reads it, including the difference between the resolution the panel has and the one the browser is handed.
Two claims made by other pixel checkers are worth dismantling before you trust one. First, automatic detection: a web page cannot see what your panel is displaying, has no access to the screen without an explicit capture permission, and would only get the composited image the operating system sent rather than the light the panel produced — so every honest pixel test is your own eyes on a flat field, and anything claiming to scan for you is scanning nothing. Second, the magnifier: enlarging a solid fill produces a larger solid fill. What genuinely helps is knowing how small the target is, which the ppi calculator turns into millimeters for your diagonal and resolution, and being able to prove what you found — which is what the copyable summary here is for, since a return request that names a position and a field survives a support call better than “there is a dot somewhere near the middle”. Two neighboring faults are also easy to misfile: an uneven pale patch rather than a hard-edged dot belongs on the backlight bleed test, and a flicker you can just about catch is usually the panel running below its rated frequency, which the refresh rate test measures directly. Both are worth ruling out before a monitor goes back in its box.
What is read from your display
Every number on this page is worked out by JavaScript running in the tab you are reading it in. Nothing you type, paste or open is uploaded, logged or kept, which is also why the tools carry on working after you disconnect from the network.
The only thing this page reads is what every web page can already see: the screen’s size in pixels and its scaling factor, used for the fault-allowance arithmetic and the marker’s device-pixel position. Your verdicts and the marked spot exist for as long as this tab is open on this page; a reload starts the walk again from an empty sheet, and the summary travels no further than the clipboard you asked it to go to.