# Lighthouse SEO Auditor MCP MCP

> The Google Lighthouse SEO Auditor immediately runs official PageSpeed Insights audits on any website. This MCP gives your agent access to performance scores (Performance, Accessibility, Best Practices, SEO) and, critically, generates exact code snippets in React, Next.js, or plain HTML showing you exactly how to fix failing metrics.

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Tags:** web-performance, technical-seo, lighthouse-audit, page-speed, frontend-optimization

## Description

Tired of paying agencies thousands just for a vague performance report? This MCP connects your agent directly to the Google PageSpeed Insights API, turning your AI into an elite technical SEO and frontend expert. You can use it to audit any website, including competitors', getting full Lighthouse scans for mobile or desktop views. The output isn't just scores; it provides actionable code fixes. If a dashboard only says 'Render-blocking resources found,' this MCP tells you *how* to fix it, providing copy/paste code right in your workflow. Since Vinkius hosts all the tools, connecting this capability means you have one place to run deep performance checks on every project without needing extra credentials or complex setup.

## Tools

### run_lighthouse_audit
Runs a full Google PageSpeed Insights audit on any public URL, returning detailed scores and suggesting exact code fixes for failures.

## Prompt Examples

**Prompt:** 
```
Audit the performance of https://vinkius.com on mobile and tell me how to get to 100/100.
```

**Response:** 
```
I've ran the Lighthouse audit. **Scores:** Performance: 72, Accessibility: 95, SEO: 100.

The main issue dragging your Performance down is a **Render-blocking resource** (`main.js` taking 1.2s to load). 
To fix this, add the `defer` attribute to your script tag. I will update your `index.html` file now to implement this change.
```

**Prompt:** 
```
Run an accessibility audit on https://github.com to see if they missed anything.
```

**Response:** 
```
I audited GitHub's homepage. They scored **100/100 on Accessibility**. However, the Best Practices score is 83/100 because of an issue with a third-party cookie missing the `SameSite` attribute. As developers, we can learn from their flawless ARIA role implementation.
```

## Capabilities

### Audit website performance and scores
Runs a full Google PageSpeed audit to calculate specific metrics for Performance, Accessibility, Best Practices, and SEO.

### Analyze competitor site health
Audits any public URL, giving you the exact Lighthouse score breakdown of a rival's website.

### Identify code-level bottlenecks
Pinpoints specific issues, such as render-blocking resources or large images, and identifies the core problem source in the codebase.

### Generate actionable code fixes
Writes exact, ready-to-use code suggestions (HTML, React, Next.js) to correct identified performance failures.

## Use Cases

### A client needs to hit a perfect 100/100 score.
The developer runs `run_lighthouse_audit` on the main landing page. The tool returns that Performance is 72 and identifies three specific render-blocking scripts. The agent then automatically writes the necessary `<script defer>` tags to fix the issue, accelerating the deployment process.

### We suspect a competitor has better image loading.
The SEO specialist uses the MCP to run an audit on a rival site's product page. The result shows their images have perfect lazy-loading implementation and optimized formats, giving the development team clear, measurable targets for improvement.

### Testing multi-platform compatibility.
The QA engineer runs two audits back-to-back: one on mobile and one on desktop. The tool highlights that a specific navigation component breaks accessibility standards only in the mobile view, allowing the fix to be targeted correctly.

### Verifying framework compatibility.
The developer builds a new Next.js widget. Before pushing it live, they run `run_lighthouse_audit` on a test page. The tool instantly flags that the component is generating large JavaScript bundles, allowing them to split code before deployment.

## Benefits

- Stop guessing. Instead of receiving vague warnings about 'render-blocking resources,' this MCP runs `run_lighthouse_audit` and gives you the precise line of React or HTML code needed to eliminate the bottleneck.
- Audit competitors instantly. You can ask your agent to check a rival's site, getting full Lighthouse scans for both mobile and desktop views to benchmark your own performance against industry leaders.
- Avoid endless manual testing cycles. By running audits right inside your workflow, you get instant feedback on whether a new feature or code refactor actually improves Core Web Vitals scores.
- Deep dive into specific failures. The tool doesn't just report low Accessibility scores; it reports *why* and provides the fix needed to pass WCAG compliance checks.
- Fast deployment validation. You can check an entire site against best practices before staging, ensuring foundational SEO elements are solid and you don't introduce costly performance regressions.

## How It Works

The bottom line is you get diagnostic metrics plus direct solutions, allowing you to fix performance problems without leaving your AI workflow.

1. You tell your agent the public URL you want audited and specify if it should be a mobile or desktop scan.
2. Your agent uses this MCP to run the full Lighthouse audit against that target site, retrieving all core scores and failing resource reports.
3. The system returns the detailed score breakdown along with specific code suggestions for fixing issues like missing attributes or slow-loading assets.

## Frequently Asked Questions

**How do I use the run_lighthouse_audit tool for SEO?**
You run `run_lighthouse_audit` on your target URL. The resulting scores (especially the 'SEO' and 'Best Practices' metrics) pinpoint issues like poor meta tags or missing structured data, along with suggestions to fix them.

**Is the Google Lighthouse SEO Auditor MCP better than manual auditing?**
Yes. Manual audits are slow and often miss specific code-level flaws. This MCP automates the process and, crucially, provides concrete fixes that you can use immediately in your development stack.

**Can I audit a competitor's site with run_lighthouse_audit?**
Absolutely. You just feed it the public URL of their website. The tool will return their full score breakdown, allowing you to benchmark against industry standards.

**Does running `run_lighthouse_audit` require me to set up API keys?**
No, you don't need any custom authentication setup. The MCP handles standard public audits automatically using the necessary Google endpoints. You just connect your agent and start calling the tool.

**If I use `run_lighthouse_audit` on a site that is blocked by a firewall, what happens?**
The MCP detects the failure immediately. It reports the specific HTTP error code or connection issue so you know exactly why the audit couldn't run. This helps you troubleshoot access problems fast.

**When `run_lighthouse_audit` finds a performance fix, what format are the suggestions in?**
The tool provides actionable code fixes that are ready to copy and paste. Suggestions come as specific snippets for React, Next.js, or pure HTML, pointing out exactly where you need to add attributes like 'defer'.

**Is `run_lighthouse_audit` limited to publicly accessible URLs only?**
Yes. This MCP is designed to audit live, publicly available web pages using the official Google PageSpeed endpoints. It cannot access private staging or local development environment URLs.

**Are there rate limits if I call `run_lighthouse_audit` many times in one session?**
The MCP manages standard usage quotas provided by the underlying API. If you exceed a limit, your agent receives a clear error message, advising you to wait or slow down your request volume.

**Do I need an API key?**
Yes. You must generate a free Google Cloud API key with the 'PageSpeed Insights API' enabled. Google limits requests to 400 per minute per project.