Lighthouse

Overview

Lighthouse.dev is a platform designed to automate and manage Google Lighthouse audits, providing tools for continuous integration performance testing and ongoing website monitoring. It addresses the need for developers and technical buyers to consistently track and improve web performance metrics. The platform is particularly suited for teams integrating performance checks directly into their CI/CD pipelines, allowing for early detection of performance regressions before they impact production environments.

The core offerings, Lighthouse Performance Monitoring and Lighthouse CI, enable users to run Lighthouse audits programmatically and store historical data. This capability is crucial for understanding performance trends, identifying specific areas for optimization, and ensuring that code changes do not inadvertently degrade user experience. For instance, a development team can configure Lighthouse.dev to run an audit on every pull request, failing the build if performance scores drop below a predefined threshold. This proactive approach helps maintain high standards for metrics like First Contentful Paint (FCP) and Largest Contentful Paint (LCP, a Core Web Vital metric according to Google's Core Web Vitals documentation).

Lighthouse.dev is beneficial for various use cases, including large-scale website performance monitoring for e-commerce sites, auditing single-page applications (SPAs) built with frameworks like React or Vue, and ensuring compliance with web performance best practices across an entire digital portfolio. Its API-driven approach facilitates custom integrations and allows for granular control over audit configurations, making it a flexible solution for diverse development workflows. By centralizing performance data and providing actionable insights, Lighthouse.dev aims to streamline the process of maintaining optimal website speed and responsiveness, directly contributing to better search engine rankings and improved user engagement.

The platform's focus on automation and integration means that performance testing can become a standard part of the development lifecycle rather than an infrequent, manual task. This shift allows developers to focus on building features with confidence that performance will be continuously validated. Technical buyers can leverage Lighthouse.dev to enforce performance budgets across multiple projects or teams, ensuring a consistent level of quality for all web properties. The platform's ability to track performance over time also aids in demonstrating the return on investment for performance optimization efforts.

Key features

• Automated Lighthouse Audits: Schedule and run Google Lighthouse audits on a regular basis or trigger them via API calls to gather performance, accessibility, SEO, and best practices scores.
• Continuous Integration (CI) Support: Integrate performance testing directly into CI/CD pipelines (e.g., GitHub Actions, GitLab CI) to prevent performance regressions from being deployed.
• Performance Monitoring: Track key performance metrics and Lighthouse scores over time, visualizing trends and identifying performance bottlenecks or improvements.
• Customizable Performance Budgets: Define thresholds for Lighthouse scores or specific metrics, receiving alerts or failing builds when budgets are exceeded.
• API for Programmatic Access: Utilize a comprehensive API to programmatically trigger audits, retrieve results, and integrate with custom reporting tools. Refer to the Lighthouse.dev API reference for details.
• Historical Data & Reporting: Store and analyze historical audit data, generating reports to understand long-term performance trends and the impact of code changes.
• Alerting & Notifications: Configure alerts for performance degradations or budget breaches, sending notifications to relevant team members via various channels.
• Multiple Test Locations: Run audits from different geographical locations to assess performance for diverse user bases.
• Web Vitals Tracking: Specifically monitor and report on Core Web Vitals such as Largest Contentful Paint (LCP), Cumulative Layout Shift (CLS), and First Input Delay (FID) to align with Google's user experience metrics.

Pricing

As of June 20, 2026, Lighthouse.dev offers a free developer tier and several paid plans. Detailed pricing information is available on their Lighthouse.dev pricing page.

Common integrations

• CI/CD Platforms: Integrate with popular CI/CD services like GitHub Actions, GitLab CI, Jenkins, and CircleCI to automate performance audits as part of the build and deployment process. The Lighthouse.dev CI integration guide provides examples.
• Version Control Systems: Connect with Git repositories (GitHub, GitLab, Bitbucket) to trigger audits on pull requests or code merges.
• Notification Services: Send alerts and reports to communication platforms such as Slack, Microsoft Teams, or email for immediate team awareness of performance changes.
• Custom Dashboards & Reporting: Export audit data via API to integrate with business intelligence tools or custom dashboards for consolidated reporting.
• Monitoring Tools: While Lighthouse.dev provides its own monitoring, data can be integrated into broader observability platforms if required.

Alternatives

• SpeedCurve: Offers comprehensive real user monitoring (RUM) and synthetic monitoring, focusing on front-end performance and Core Web Vitals. Their SpeedCurve features overview details their capabilities.
• Calibre: Provides synthetic monitoring, Lighthouse audits, and performance budgets with a strong emphasis on continuous performance improvement.
• DebugBear: Specializes in continuous web performance monitoring, offering Lighthouse checks, detailed metrics, and regressions detection.

Getting started

To get started with Lighthouse.dev, you typically use their API to trigger audits and retrieve results. Here's a basic Node.js example using node-fetch to interact with the Lighthouse.dev API, assuming you have an API key and a project ID.

const fetch = require('node-fetch');

const API_KEY = 'YOUR_LIGHTHOUSE_DEV_API_KEY'; // Replace with your actual API key
const PROJECT_ID = 'YOUR_PROJECT_ID';       // Replace with your project ID
const PAGE_URL = 'https://example.com';      // The URL to audit

async function triggerLighthouseAudit() {
  try {
    // Step 1: Trigger a new audit
    console.log(`Triggering Lighthouse audit for ${PAGE_URL}...`);
    const triggerResponse = await fetch(`https://api.lighthouse.dev/v1/projects/${PROJECT_ID}/audits`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${API_KEY}`
      },
      body: JSON.stringify({
        url: PAGE_URL,
        // Optionally add specific Lighthouse categories or settings
        // categories: ['performance', 'accessibility'],
        // device: 'mobile'
      })
    });

    if (!triggerResponse.ok) {
      const errorBody = await triggerResponse.json();
      throw new Error(`Failed to trigger audit: ${triggerResponse.status} ${triggerResponse.statusText} - ${JSON.stringify(errorBody)}`);
    }

    const triggerResult = await triggerResponse.json();
    const auditId = triggerResult.auditId;
    console.log(`Audit triggered successfully. Audit ID: ${auditId}`);

    // Step 2: Poll for audit results (simplified for example, in production use webhooks or longer polling intervals)
    console.log('Waiting for audit to complete...');
    let auditStatus = 'pending';
    let auditResults;

    while (auditStatus !== 'completed' && auditStatus !== 'failed') {
      await new Promise(resolve => setTimeout(resolve, 5000)); // Wait 5 seconds
      const statusResponse = await fetch(`https://api.lighthouse.dev/v1/audits/${auditId}`, {
        headers: {
          'Authorization': `Bearer ${API_KEY}`
        }
      });

      if (!statusResponse.ok) {
        const errorBody = await statusResponse.json();
        throw new Error(`Failed to get audit status: ${statusResponse.status} ${statusResponse.statusText} - ${JSON.stringify(errorBody)}`);
      }

      const statusResult = await statusResponse.json();
      auditStatus = statusResult.status;
      auditResults = statusResult;
      console.log(`Current audit status: ${auditStatus}`);
    }

    if (auditStatus === 'completed') {
      console.log('\nAudit Completed! Here are the core scores:');
      console.log(`Performance Score: ${auditResults.scores.performance}`);
      console.log(`Accessibility Score: ${auditResults.scores.accessibility}`);
      console.log(`SEO Score: ${auditResults.scores.seo}`);
      // Full results are available in auditResults.report or auditResults.metrics
    } else {
      console.error('Audit failed to complete.');
    }

  } catch (error) {
    console.error('Error during Lighthouse audit process:', error.message);
  }
}

triggerLighthouseAudit();

This Node.js script demonstrates how to initiate a Lighthouse audit for a given URL and then poll its status until completion. In a production environment, it is recommended to use webhooks provided by Lighthouse.dev for real-time notifications of audit completion rather than continuous polling, as outlined in their Lighthouse.dev webhook documentation. This example focuses on the core interaction of triggering an audit and retrieving summary scores. The full audit report, including detailed metrics and suggestions, would be available in the auditResults object.