Lighthouse

Overview

Lighthouse is a web performance monitoring solution built around Google Lighthouse audits. It provides tools for automating performance checks, tracking key metrics, and integrating these processes into development workflows. The platform is designed for developers and technical teams seeking to maintain and improve the performance of their web applications and websites.

The core functionality of Lighthouse involves running Google Lighthouse audits on a scheduled basis or as part of a continuous integration (CI) pipeline. Google Lighthouse itself is an open-source, automated tool for improving the quality of web pages. It audits performance, accessibility, progressive web apps, SEO, and more. Lighthouse extends this by offering a hosted service to run these audits persistently, store historical data, and provide reporting features.

Users can configure Lighthouse to monitor specific URLs, set performance budgets, and receive alerts when metrics degrade. This makes it suitable for identifying performance regressions early in the development cycle, rather than in production. For example, if a new code deployment introduces a slower Largest Contentful Paint (LCP), Lighthouse can flag this deviation from established benchmarks.

The platform offers a Developer Free Tier, with paid plans starting at $49/month for the Startup tier. Its primary use cases include continuous integration performance testing, ongoing website performance monitoring, and identifying performance issues introduced by new code deployments. Developers can interact with Lighthouse through its API, allowing for programmatic control over audits and data retrieval. This facilitates integration with custom dashboards, reporting tools, and existing CI/CD systems, enhancing developer experience by providing clear examples in its documentation for common use cases.

While Google Lighthouse provides ad-hoc auditing capabilities directly in browsers or via command line, Lighthouse focuses on the operationalization of these audits for ongoing monitoring. This includes establishing performance baselines, setting up alerts for budget violations, and providing a historical view of performance trends. This approach contrasts with tools that focus solely on synthetic testing from a single location, by emphasizing the integration of performance validation directly into the development and deployment lifecycle.

Key features

• Automated Google Lighthouse Audits: Runs comprehensive Google Lighthouse audits on specified URLs at regular intervals or on demand, covering performance, accessibility, SEO, and best practices (Learn about Google Lighthouse audits from web.dev).
• Performance Monitoring: Tracks critical web performance metrics such as Largest Contentful Paint (LCP), Total Blocking Time (TBT), and Cumulative Layout Shift (CLS over time, providing historical data and trend analysis.
• Performance Budgets: Allows users to define thresholds for specific performance metrics and receive alerts when these budgets are exceeded, helping to prevent performance regressions.
• CI/CD Integration: Provides tools and documentation for integrating performance audits directly into continuous integration and continuous deployment pipelines, enabling automated performance checks before code is merged or deployed.
• API Access: Offers a programmatic API for triggering audits, retrieving results, and integrating Lighthouse data with other development tools and custom reporting systems (Access the Lighthouse API Reference).
• Historical Data and Reporting: Stores audit results over time, presenting them through dashboards and reports that visualize performance trends and changes.
• Alerting: Configurable notifications via email or other channels when performance metrics degrade or budgets are violated.

Pricing

Lighthouse offers a free developer tier and tiered subscription plans, current as of June 2026. Custom enterprise solutions are available upon request.

For detailed pricing information and current offerings, refer to the Lighthouse pricing page.

Common integrations

• GitHub Actions: Integrate Lighthouse CI into GitHub Actions workflows to automate performance checks on pull requests and deployments (Set up Lighthouse CI with GitHub Actions).
• GitLab CI/CD: Implement Lighthouse checks within GitLab CI/CD pipelines to ensure performance standards are met before merging code.
• Bitbucket Pipelines: Automate Lighthouse audits as part of Bitbucket Pipelines for continuous performance monitoring.
• Slack: Receive performance alerts and reports directly in Slack channels.
• Custom CI/CD Systems: Utilize the Lighthouse API to integrate with other CI/CD platforms like Jenkins, CircleCI, or custom build systems.
• Webhooks: Configure webhooks to push audit results or alerts to other services and custom applications.

Alternatives

• SpeedCurve: Offers comprehensive web performance monitoring with real user monitoring (RUM) and synthetic testing capabilities.
• Calibre: Provides performance monitoring, budgeting, and alerting, focusing on a robust user interface and team collaboration features.
• DebugBear: Specializes in website speed monitoring and performance regression detection, offering detailed reports and integrations for developer workflows.

Getting started

To get started with Lighthouse, you typically register an account, create a project, and then configure the URLs you want to monitor. The platform provides a client library for Node.js to interact with its API programmatically, allowing you to trigger audits and fetch results from your local environment or CI/CD pipeline. Below is an example of how to use the Lighthouse Node.js client to trigger an audit and retrieve its results, assuming you have an API key configured.

First, install the Lighthouse client library:

npm install @lighthouse-dev/client

Then, you can use the client in your Node.js application:

const LighthouseClient = require('@lighthouse-dev/client');

// Initialize the client with your API key
const client = new LighthouseClient({ apiKey: 'YOUR_API_KEY' });

async function runAudit() {
  try {
    // Define the audit configuration
    const auditConfig = {
      url: 'https://example.com',
      strategy: 'desktop', // 'desktop' or 'mobile'
      location: 'us-east-1', // or other available locations
    };

    console.log(`Triggering audit for ${auditConfig.url}...`);

    // Trigger the audit
    const audit = await client.audits.create(auditConfig);
    console.log(`Audit started with ID: ${audit.id}`);

    // Poll for audit completion (simplified for example)
    let result;
    do {
      await new Promise(resolve => setTimeout(resolve, 5000)); // Wait 5 seconds
      result = await client.audits.get(audit.id);
      console.log(`Audit status: ${result.status}`);
    } while (result.status === 'pending' || result.status === 'running');

    if (result.status === 'completed') {
      console.log('Audit completed successfully!');
      console.log('Performance Score:', result.data.performanceScore);
      console.log('First Contentful Paint:', result.data.fcp);
      console.log('Largest Contentful Paint:', result.data.lcp);
      // Access full Lighthouse report data via result.data.lighthouseReport
    } else {
      console.error('Audit failed:', result.error);
    }

  } catch (error) {
    console.error('Error running audit:', error.message);
  }
}

runAudit();

This example demonstrates initiating an audit for a specified URL and then polling its status until completion. The retrieved result.data object will contain key performance metrics and the full Lighthouse report data, which can then be parsed and used for further analysis or reporting. For more detailed instructions and advanced configurations, including setting up CI/CD integrations, consult the Lighthouse documentation.