ISSUE 067  ·  17 NOVEMBER 2026 ELEN RSS
CodeCity
DESIGN № 0050

Lighthouse: the auditor that opens your page and tells you what is broken

Lighthouse is a free program that opens a web page in a browser with no window — nothing appears on screen, the machine loads the page in the background and waits for it to settle — and then puts it through 161 checks, one at a time. When it finishes it hands you four scores out of 100: how fast the page feels, how usable it is for people with disabilities, whether it follows the established good practices of the web, and whether search engines can make sense of it. Alongside the scores you get the name of every check that failed and the reason it failed. Google builds it, and it is the same tool hiding behind the well-known PageSpeed Insights, with one difference: this one runs on your own machine, from the command line, without sending your page anywhere.

Lighthouse: ο ελεγκτής που ανοίγει τη σελίδα σου και σου λέει τι χαλάει

What it does

Picture this: you have delivered a web page and you want to know whether it holds up. You would open it in a browser and look at it. But the eye cannot measure the contrast of a pale grey text on a white background. It does not notice that a button carrying only an icon says nothing to someone using a screen reader. It does not know why the page takes three seconds on a phone.

Lighthouse does that work in place of the eye. It opens the address you give it inside a Chrome with no window — that is what “headless” means: the browser runs normally, loads the page, executes the JavaScript, but draws nothing on screen. Once the page settles, the program runs 161 checks. Some measure timings, some read the HTML looking for image descriptions, some test whether colours contrast enough, others look for a title and a description that search engines can read.

Then it groups the checks into four categories and gives each category a score out of 100. Performance. Accessibility. Best practices. SEO — that is, how understandable the page is to automated visitors such as Google. The score is a number; the useful part is the list underneath it. For every check that failed you get its name, what it expected, what it found, and often a link to the explanation. It does not say “accessibility is 53”. It says “the check button-name failed: the button has no text and no label”.

The project is maintained by the GoogleChrome team. Today the repository holds 31,026 stars and 9,785 forks, with 438 open issues — many for a ten-year-old tool, which tells you people use it in unlikely places. The latest release is 13.6.0, published on 27 October 2026, and the last push to the repository landed on 6 November 2026. It is not abandoned; it gets touched every few days. It is downloaded 7,285,288 times a week from npm, meaning thousands of automated pipelines run it with no human in front. It ships under Apache-2.0, so you may embed it in your own product, with attribution.

One detail explains why you should trust it: PageSpeed Insights, Google’s familiar web tool, is not something else. It is this program, wrapped in a page. Whatever score you see there, the same software produced it.

What it doesn’t do

First and most important: it does not check security. It does not hunt for vulnerabilities, does not spot keys leaked into code, does not judge your server configuration. A score of 100 does not mean “secure page”. It means “it passed the checks this tool has”, and those checks are about experience, not protection.

Second: it fixes nothing. It tells you what is missing and why, but the button’s text, the image’s label and the dark grey on light grey are yours to change. It is a mirror, not a mechanic.

Third: it does not audit the whole site. You give it one address and it examines one page. For the rest you run it again. It does not crawl links, does not map your site, does not compare pages to each other.

Fourth: it does not monitor on its own. It is not a service running in the background that alerts you when something breaks. You run it when you want it, or you put it inside an automation script and let that run it.

Fifth, and this is by design rather than a flaw: it is not an MCP server. It loads no schema for a model to pick up, it exposes no “tools” an agent can see by itself. You drive it from the command line, like any other program.

Sixth: it cannot walk into pages behind a login without work. If your page needs an account, you have to hand it the credentials the right way, otherwise what it audits is the login page, not the page you care about.

And seventh: it is no substitute for testing on a real device. The program loads the page with a throttled network speed and an artificially limited processor, to imitate a mid-range phone. That is useful and fair, but it is still a simulation.

Who it’s for

For anyone who delivers web pages and wants a second pair of eyes backed by instruments instead of opinions. For the designer who built something beautiful and does not know whether the grey text is readable. For the developer who changed the layout and wants to know whether speed was lost. For the SEO person who wants to see the page the way machines see it. For the small team with no measurement lab of its own.

It is not for anyone who wants a dashboard tracking a thousand pages around the clock — other commercial products do that, and PageSpeed Insights itself does it for free if you hand it the address. Lighthouse is for the moment you are looking at one page and want an answer right now, locally, without sending it anywhere.

Installation

You install it from the command line, inside a folder you create yourself so the rest of your system does not fill up with its files. First make sure you have Node 22.19 or newer — the package asks for that in its own engines field, the README does not mention it, and it is the most common cause of an error at the start.

Create the folder:

mkdir lh

Go into it:

cd lh

And install the tool:

npm install lighthouse@13.6.0

The prerequisite npm never mentions

Lighthouse does not bring its own browser. It needs Chrome installed on the machine. Without it, no page opens, however correct everything else is. Most of the time it finds Chrome itself. If it does not, you point it at the binary with the CHROME_PATH variable:

export CHROME_PATH="C:/Program Files/Google/Chrome/Application/chrome.exe"

On other operating systems the path differs — the binary is called google-chrome on most Linux distributions, and lives inside the applications folder on macOS. The point is the same everywhere: the variable must point at a Chrome that exists.

Alternative: a global install

If you want the command available everywhere, without entering the folder each time, install it globally:

npm install -g lighthouse

After that it runs by name, from wherever you are.

Alternative: no install at all

If you want to try it and leave nothing on disk, npm can fetch it, run it and throw it away in one move:

npx lighthouse@13.6.0 https://example.com

That is handy for a single test. For daily use, the local install is better: you have it, you know which version you are running, and you do not wait for a download every time.

Using it with each LLM

Worth being clear here: Lighthouse is not an MCP server, it has no tools a model discovers by itself. There is no schema to load, no setting to add to a file. Every client uses it the same way: you give the agent a shell, you tell it to run the command, and then you tell it to read the report file. That file is JSON — structured information a program and a human can both read.

The command is identical everywhere. It runs the page, writes the report to a file, and uses Chrome with no window and no graphics card:

./node_modules/.bin/lighthouse https://example.com --output=json --output-path=./lh.json --chrome-flags="--headless=new --no-sandbox --disable-gpu"

That headless and disable-gpu part is why it works even on a machine with no graphics card or in an environment with no display. Keep it as it is.

Claude Code

Claude Code runs shell commands after asking your permission, from inside the project folder. Run the install once, then hand it the command as a normal request — something like “run Lighthouse against localhost:3000 and show me what failed”. It will execute the command, ask for approval, then read lh.json from disk, because it is just a file in the folder. The gain is that you never explain what each check means: the check’s name and description are inside the file.

./node_modules/.bin/lighthouse http://localhost:3000 --output=json --output-path=./lh.json --chrome-flags="--headless=new --no-sandbox --disable-gpu"

Codex CLI

Codex CLI runs in the terminal inside a safety sandbox. If the sandbox blocks an outbound network connection or a file write, it will ask for approval — grant it for this command, because Lighthouse does both: it goes to the network to load the page and writes lh.json. Give it the same command, from the folder where you installed.

./node_modules/.bin/lighthouse http://localhost:3000 --output=json --output-path=./lh.json --chrome-flags="--headless=new --no-sandbox --disable-gpu"

Cursor

Cursor is an editor with a built-in terminal and an agent. Open its terminal, run the install once, then let the agent run the command in that same terminal. The nice part comes after: you can tell it “open lh.json and show me only the accessibility failures” — the file is inside the project, the editor sees it, and the agent filters it without re-running anything.

./node_modules/.bin/lighthouse http://localhost:3000 --output=json --output-path=./lh.json --chrome-flags="--headless=new --no-sandbox --disable-gpu"

With every client the pattern is the same: one command writes the report, the agent reads it, and then you work on it together. You do not need to teach it what Lighthouse is; you need to give it a shell and a folder.

Where it wins, where it loses

It wins on three fronts. First: it does not give you an opinion, it gives you names. A failed check has a name, a description and often a link to the fix — so the agent has something concrete to work on, not a vague “make it more accessible”. Second: it works locally and without a display, so it can run inside an automation, inside a continuous integration script, or in an environment with no graphics card. Third: it is the same software as PageSpeed Insights, so the score you produce is the score your client sees.

It loses on one point, and it is the most misunderstood: the performance score is not stable. On a slow machine or shared Wi-Fi it moves with every run. The same page can give 0.96 one time and 0.88 the next with nothing changed. If you need the performance number to make a decision, run it three times and take the median — the middle value, not the average, because a single bad run drags the average down. What stays stable is the set of checks and the names of the failures; those do not change between runs. Whoever chases the number and ignores the list is wasting their time.

We looked elsewhere too, and it is worth saying so. Underneath Lighthouse, accessibility is checked by a library called axe-core — that is the engine, Lighthouse is the shell around it. It sits behind millions of weekly downloads and it is excellent. Tested as a standalone command-line program, though, it breaks, because it asks for a specific Chrome driver version and Chrome has moved on. The recommendation is clear: use it as a library inside your own test suite, where you pin the versions, not as a tool you call by hand. Lighthouse does not have that problem, because it talks to Chrome its own way.

The test

We ran the following sequence from scratch, in a clean folder:

mkdir lh && cd lh
npm i lighthouse@13.6.0
export CHROME_PATH="C:/Program Files/Google/Chrome/Application/chrome.exe"
./node_modules/.bin/lighthouse https://example.com --output=json --output-path=./lh.json --chrome-flags="--headless=new --no-sandbox --disable-gpu"
node -e "const r=require('./lh.json');for(const k of ['performance','accessibility','best-practices','seo'])console.log(k,r.categories[k].score)"

Installation took 2 minutes 7 seconds and left 181 MB across 99 packages. The run took 17.5 seconds and executed 161 checks — the tool’s internal timing measured 10.6 seconds; the difference is Chrome starting up.

The most convincing part came after. We deliberately built a broken page: an image with no description, a button with only an icon and no text, text with low contrast, targets too small for a finger, and no main landmark in the structure. The tool returned performance 0.96 and accessibility 0.53, and named all five lost checks correctly: button-name, color-contrast, image-alt, target-size, landmark-one-main. It found nothing we did not hide from it, and missed nothing we did. That is the answer to “is it worth it?” — whatever you put in front of it, it saw.

What was not tested today, we say plainly: the steps inside Claude Code, Codex CLI and Cursor are the general route — each gives the agent a shell and the agent reads the file. What was tested, measured and is repeatable is the Lighthouse command and the contents of the report.

What it costs

It is not an MCP server, so it loads no schema into the model: zero tokens on either side. The real cost is time, disk, and one prerequisite.

Measured in a clean folder: installation took 2 minutes 7 seconds and left 181 MB across 99 packages. The package itself is 18.5 MB with 982 files and 22 direct dependencies. A run takes 17.5 seconds and executes 161 audits.

The prerequisite npm does not mention: it needs Chrome installed. Without it, no page opens, however correct everything else is. And it needs Node 22.19 or newer — from the package’s engines field, not from the README.

In money: zero. It sends your page nowhere, needs no account, no key. The expense is the time of the person who will read four scores and decide what to fix first — and that is the one thing the tool cannot measure.

Verdict

Yes, it is worth it, on one condition: read the list, not the number. Lighthouse is the cheapest second pair of eyes you can put on a page — free, local, no account, and with a name for everything that goes wrong. Put it in your delivery flow: run it before you send the page to the client, look at the accessibility failures, fix them, run it again. Leave performance for when you have three measurements, otherwise it is noise.

And a note on the column: this is a design tool, not a security tool. It measures the experience you deliver — contrast, names, weight, structure. Keep it for what it actually does, and it will never disappoint you.

Sources:

https://github.com/GoogleChrome/lighthouse

https://developer.chrome.com/docs/lighthouse/overview

https://github.com/GoogleChrome/lighthouse/releases/tag/v13.6.0