WebPageTest

Overview

WebPageTest is an open-source platform designed for evaluating and optimizing web page performance. Originally developed by Patrick Meenan at AOL in 2008, it provides detailed insights into how web pages load and render, offering metrics that extend beyond simple load times to include visual completeness and user-centric performance indicators like Core Web Vitals. The tool operates by simulating real user conditions, testing pages from various geographic locations, browsers, and connection speeds. This granular approach allows technical users to pinpoint specific areas of improvement, such as render-blocking resources, inefficient image loading, or server response times.

The platform is suitable for web developers, performance engineers, and technical SEO specialists who require a deep understanding of frontend performance characteristics. Its capabilities range from ad-hoc testing on its public instance to integrated performance monitoring within continuous integration/continuous delivery (CI/CD) pipelines. For example, a developer can run a test from a specific city using a mobile device profile and a 3G connection to understand the experience of a user in that context. The results include waterfall charts, video capture of page load, and detailed resource breakdowns, which are critical for diagnosing complex performance issues that might not be evident from simpler tools.

WebPageTest excels in scenarios requiring precise control over testing parameters and comprehensive data output. This includes A/B testing performance optimizations, benchmarking against competitors, or ensuring adherence to specific performance budgets. Its open-source nature has fostered a community of contributors and enabled its integration into various other tools and services. While a free public version is available for individual tests, commercial offerings under Catchpoint provide advanced features such as private instances, API access for automated testing, and enhanced reporting, catering to enterprise-level requirements for continuous performance monitoring and compliance with standards like Google's Core Web Vitals.

The extensive configurability allows users to simulate various network conditions, user agents, and even block specific domains or elements to isolate performance impacts. This level of control is particularly beneficial for diagnosing third-party script performance, ad network overhead, or the impact of A/B testing tools. The platform's commitment to providing raw, actionable data distinguishes it from tools that offer more abstract performance scores, making it a valuable resource for technical buyers focused on engineering-driven performance improvements.

Key features

• Detailed Waterfall Charts: Visual representation of all resources loaded on a page, showing load order, timing, and dependencies, which aids in identifying critical path bottlenecks.
• Video Capture and Filmstrip View: Records the page loading process visually, allowing users to see exactly when content renders and identify visual completeness metrics like First Contentful Paint and Largest Contentful Paint.
• Core Web Vitals Reporting: Provides specific metrics for Google's Core Web Vitals (LCP, FID, CLS), essential for SEO and user experience.
• Global Test Locations: Offers a wide range of test agents located worldwide, enabling performance analysis from different geographic regions and simulating diverse user experiences.
• Browser and Device Emulation: Tests pages across various desktop and mobile browsers (e.g., Chrome, Firefox, Safari) and emulates different device types and screen resolutions.
• Custom Scripting and Authentication: Supports scripting complex user journeys, including login sequences and multi-page flows, for comprehensive performance measurement of dynamic web applications.
• API for Automation: Provides a robust WebPageTest API reference for integrating performance testing into CI/CD pipelines, enabling automated regression testing and performance monitoring.
• Advanced Network Throttling: Configurable network conditions to simulate various connection speeds (e.g., 3G, 4G, DSL) and latency, offering realistic performance insights for diverse user networks.
• Content Blocking: Ability to block specific domains or resources during tests to evaluate the performance impact of third-party scripts, ads, or analytics tools.
• Custom Metrics and User Timings: Allows for the definition and measurement of custom performance metrics using JavaScript or User Timing API, providing flexibility for specific application needs.

Pricing

WebPageTest offers a free public instance for basic testing, with paid tiers providing expanded capabilities, more credits, and advanced features. The commercial plans are structured to support varying levels of usage, from individual developers to large enterprises.

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

Common integrations

• CI/CD Pipelines: Integrate the WebPageTest API with tools like Jenkins, GitHub Actions, or GitLab CI to automate performance regression testing on every code commit.
• Monitoring Dashboards: Export performance data to platforms such as Grafana or Datadog for centralized monitoring and visualization of web performance trends.
• Alerting Systems: Configure alerts in tools like PagerDuty or Slack based on performance thresholds defined in WebPageTest, notifying teams of significant performance degradations.
• Custom Reporting Tools: Utilize the API to pull raw performance data into custom data warehouses or business intelligence tools for tailored analysis and reporting.
• Google Lighthouse: WebPageTest often integrates Lighthouse audits into its reports, providing an additional layer of best practice recommendations alongside its detailed performance metrics, as explained in Google's guidance on page experience.

Alternatives

• Google PageSpeed Insights: Offers performance and accessibility audits based on Lighthouse, providing both lab and field data for web pages.
• GTmetrix: Provides detailed reports on page performance, including YSlow and Google Lighthouse scores, with a focus on actionable recommendations.
• SpeedCurve: A synthetic monitoring and RUM platform offering advanced performance analytics, dashboards, and alerting for continuous web performance optimization.
• Botify: A unified suite for enterprise SEO, including technical SEO, keyword research, content optimization, and performance monitoring, contrasting with WebPageTest's specialized focus.

Getting started

To perform a basic page speed test using WebPageTest's public instance, you can use a simple curl command to interact with its API. This example initiates a test for a specified URL and retrieves the test ID, which can then be used to fetch the results.

# Replace YOUR_API_KEY with your actual WebPageTest API key
# You can obtain an API key from your WebPageTest account or a free key from the public instance (if available)
API_KEY="YOUR_API_KEY"
URL="https://www.example.com"

# Initiate a test and get the test ID
response=$(curl -s "https://www.webpagetest.org/runtest.php?url=${URL}&f=json&k=${API_KEY}")
testId=$(echo ${response} | jq -r '.data.testId')

if [ "${testId}" != "null" ]; then
  echo "Test initiated successfully. Test ID: ${testId}"
  echo "You can view results at: https://www.webpagetest.org/result/${testId}/"
  echo "Waiting for test to complete..."

  # Poll for results until the test is complete (this is a simplified example)
  while true; do
    status_response=$(curl -s "https://www.webpagetest.org/jsonResult.php?test=${testId}&k=${API_KEY}")
    statusCode=$(echo ${status_response} | jq -r '.statusCode')
    
    if [ "${statusCode}" == "200" ]; then
      echo "Test complete. Full results JSON:"
      echo ${status_response} | jq .
      break
    elif [ "${statusCode}" == "100" ] || [ "${statusCode}" == "101" ]; then
      echo "Test status: ${statusCode} - Waiting..."
      sleep 10 # Wait for 10 seconds before polling again
    else
      echo "Error during test: ${statusCode} - $(echo ${status_response} | jq -r '.statusText')"
      break
    fi
  done
else
  echo "Failed to initiate test." | jq .
fi

This script uses curl to make HTTP requests and jq for parsing JSON responses. Ensure you have jq installed (sudo apt-get install jq or brew install jq). Replace YOUR_API_KEY with a valid API key obtained from WebPageTest. The script first runs a test for https://www.example.com and then polls the API for results until the test is complete, printing the final JSON output. For more detailed API usage, including advanced configuration options, refer to the WebPageTest API documentation.