Lighthouse and PageSpeed Insights. One local console. Free.
LightAudit Score runs Lighthouse on your machine, so it audits localhost, staging and VPN sites that hosted tools can't reach. Whole sites in one batch, median-of-N runs for numbers you can defend, Google's real-user field data next to your lab scores, and an AI that explains why a score is low and how to fix it. Your Chrome, your keys, your AI. $0.
Audit the pages Google can't see.
PageSpeed Insights needs a public URL. LightAudit runs the same Lighthouse v13 engine on your own machine, so localhost:3000, a staging box behind a VPN, and the intranet app nobody can link to all get audited exactly the same way.
Localhost, staging, VPN, intranet
If your Chrome can open it, LightAudit can audit it. No tunnels, no temporary public URLs, no "we'll check it after deploy".
Whole sites in one batch
Paste a list of URLs, or crawl a site: sitemap plus a robots-aware, same-origin crawl with depth, max-page and exclude-path controls. Preview the discovered pages, then audit them all.
Live, per-URL progress
Every page streams queued → running → done with score rings and Core Web Vitals (LCP, CLS, TBT, FCP, SI, TTI) as they land. Open the full Lighthouse HTML report from any card.
Desktop + mobile, paired
Audit both form factors in one run and read them side by side, instead of running everything twice and reconciling by hand.
Numbers you can defend in a code review.
Lighthouse Performance swings about ±5 points on identical runs, because Total Blocking Time is CPU-sensitive and worth roughly 30% of the score. One run is an anecdote. LightAudit is built around making the number trustworthy.
Median of N, isolated Chrome, one job per process
Each URL is audited N times (default 3) and Lighthouse's own computeMedianRun picks the representative run. Every run launches a fresh headless Chrome with a cold profile, and every job runs in its own forked Node process so concurrent audits can't poison each other's timings.
Calibrate to your hardware
Lighthouse's default 4× CPU throttle only lands on "mid-tier mobile" from a high-end desktop. A fast Mac under-throttles and reads optimistically. Calibrate reads your host's benchmarkIndex and picks the multiplier that targets mid-tier mobile from your machine.
Match DevTools preset
One click sets mobile, simulated throttling, single run, concurrency 1 and Lighthouse's own 4×, so a local number is directly comparable to the Chrome DevTools Lighthouse panel on the same machine.
Drift warnings and an environment badge
Every result shows the host power, throttling method and multiplier it ran under, and flags when the machine, not the page, moved the score: host-power drift, CPU contention, or concurrency contention. Accuracy mode serialises Performance runs automatically.
Lab and field, in the same table.
Lab scores tell you what the page does in a controlled run. Field data tells you what real Chrome users experienced. You normally get them from two different tools with two different histories. Here they share one.
PageSpeed Insights, built in
The same paste-or-crawl input, audited by Google's hosted Lighthouse instead of your Chrome. Runs carry a cyan PSI badge in History so you never confuse the two.
Real-user Core Web Vitals from CrUX
LCP, INP and CLS at the 75th percentile, per URL and per origin, with good / needs-improvement / poor distribution bars beside the lab scores.
Your own free Google key
PSI needs an API key now (keyless calls are capped at zero). LightAudit walks you through creating one; the free tier is 25,000 requests a day, per user. The key is read server-side from your .env and never sent to the browser.
Ask why. Get prioritised, cited fixes.
A score tells you something is wrong. Click it and the AI reads the actual audit data, explains what's dragging the category down, and returns concrete fixes with steps, a priority, and, when a research server is connected, citations to sources it actually opened.
Analyses are stored with the run, so reopening a report costs nothing.
Researching · fetched web.dev/lcp
Diagnosis. LCP is 2.9 s because the hero image is a 1.4 MB PNG served at native resolution and discovered late by the preload scanner. TBT (380 ms) comes almost entirely from a single 640 kB analytics bundle that executes on the main thread before hydration.
Serve the hero as responsive AVIF and preload it
HighCuts the LCP resource by ~85% and lets the browser discover it before CSS resolves.
- Export the hero at 640 / 1280 / 1920 widths as AVIF with a WebP fallback.
- Use
<img srcset sizes fetchpriority="high">for the above-the-fold image. - Add
<link rel="preload" as="image">for the largest candidate.
Defer the analytics bundle off the critical path
MediumRemoves ~300 ms of main-thread blocking during load; TBT is ~30% of the Performance score.
- Load it with
deferor afterrequestIdleCallback. - Split vendor tracking into its own chunk so it isn't blocking hydration.
Your Claude Code login
Already signed in on this machine? Nothing to configure. The only path that can browse and cite. Or set an API key.
Local model, offline
Private and free. Pick any installed tag from Settings; 14B+ with a large context works best.
Any OpenAI-compatible endpoint
OpenAI, OpenRouter, LM Studio, vLLM. Base URL, model id, key. Read from the environment at request time, never stored.
Honest by design
Every analysis is badged with the provider and model that produced it. If no research server is connected the fixes are diagnosed from audit data alone and carry a plain No web research badge. It never invents a source. LightAudit ships no AI credentials, bundles no third-party software, and never stores or forwards a key.
Why not just use Lighthouse and PageSpeed Insights separately?
You can. Both are free and excellent, and LightAudit is built on the first and calls the second. What it adds is everything around them: reach, repetition, memory and explanation.
| Capability | Lighthouse DevTools panel / CLI |
PageSpeed Insights | LightAudit Score |
|---|---|---|---|
| Audits localhost, staging, VPN, intranet | Yesone page at a time | Nopublic URLs only | Yes |
| Whole-site batches from a crawl or a pasted list | Noscript it yourself | Noone URL per run | Yessitemap + robots-aware crawl |
| Median-of-N with isolated Chrome per run | Manualrun it 3–5× and take the median yourself | Nosingle run | Yesdefault 3, per-job process isolation |
| Calibration to your host, drift warnings | NobenchmarkIndex buried in the JSON | n/a | YesCalibrate · Match DevTools · env badge |
| Real-user Core Web Vitals (CrUX field data) | No | Yes | Yeswith your own free Google key |
| Persisted history, trends, two-run diff | Nosave the HTML yourself | No | YesSQLite + full JSON/HTML reports on disk |
| Batch pass/fail thresholds, CSV / JSON export | No | No | Yes |
| Scheduled daily runs | Cronif you build it | No | Yeswhile the app is running |
| AI diagnosis with prioritised, cited fixes | No | No | Yesyour Claude, Ollama or any compatible endpoint |
| Unlimited runs, no account | Yes | Quota25k/day with a key | Yes |
| Price | Free | Free | Free · open source · MIT |
Every run, kept. Every change, visible.
Hosted tools forget the moment you close the tab. LightAudit writes every run to a local SQLite database plus the full Lighthouse JSON and HTML reports on disk, so history survives restarts and lives with you.
A sortable, filterable archive
Every persisted run by URL, date and score. Open the stored HTML report for any of them.
Trend charts and a two-run diff
Per-URL score trends with sparklines, and a before/after diff of category scores and Core Web Vitals with direction.
Pass / fail at a glance
Averages, best and worst page, and pass/fail counts against your own per-category thresholds. Export JSON or CSV, open every report at once.
Scheduled daily runs
Save a batch as a daily schedule and build a running archive of a site while the app is up. Re-run or regenerate any batch later.
Remembered defaults
Device, runs, concurrency, categories, thresholds and your calibrated CPU multiplier persist between visits.
Free. Not "free tier". Free.
The audience is developers, and the marginal cost of an audit on your own machine is zero. So there's no account, no licence, no usage cap, and no upsell hiding behind the third audit.
- Unlimited local audits and whole-site crawls
- History, compare, trends, batches, schedules
- PageSpeed Insights + CrUX field data
- AI analysis with cited fixes
- Open source under MIT, runs from a clone
Your machine, your keys
- Node.js 24+ and Google Chrome
- Optional: your own free Google API key for PageSpeed Insights
- Optional: your Claude login, an Ollama model, or any compatible endpoint for AI analysis
- Optional: a research MCP server you run yourself, so fixes can cite sources
No strings
- Phone home or send your audits anywhere
- Store or forward any of your keys
- Bundle, install or advertise third-party software
- Ask you to create an account
- Expose itself beyond localhost unless you say so
Three commands to a working console.
It's a plain Next.js app you run yourself. First start builds once (about a minute); later starts come up in about a second. It binds to loopback only, by default.
$ git clone https://github.com/…/lightaudit.git $ cd lightaudit && npm install $ npm start › building once… ✓ LightAudit Score on http://127.0.0.1:3000 # optional: one URL from the terminal, no UI $ npm run audit -- https://example.com
The repository goes public shortly. Leave your email and you'll get the link the moment it does.
Want the link when it's live?
One email with the repository, the quick start and nothing else. It helps to know what you'd audit first.