Bulk PageSpeed Insights Website Speed Test

Understanding the PageSpeed Insights API

The PageSpeed Insights API is Google's programmatic interface for accessing performance analysis data. The API accepts a URL parameter and returns detailed performance metrics in JSON format.

API Endpoint and Authentication

The primary API endpoint is https://www.googleapis.com/pagespeedonline/v5/runPagespeed. This endpoint accepts the target URL as a query parameter and returns comprehensive performance data. For higher usage limits, developers can obtain an API key from the Google Cloud Console.

Without an API key, requests are rate-limited. For production use and bulk testing, obtaining and configuring an API key is recommended. The API key can be added using the key query parameter.

Response Structure

The API response contains several key sections. The lighthouseResult object provides lab data from Lighthouse simulations, including overall performance scores and individual audit results. The loadingExperience object contains field data from real users, aggregated from the Chrome User Experience Report.

{
 "lighthouseResult": {
 "categories": {
 "performance": {
 "score": 0.92,
 "title": "Performance"
 }
 },
 "audits": {
 "largest-contentful-paint": {
 "numericValue": 2100,
 "displayValue": "2.1 s"
 },
 "cumulative-layout-shift": {
 "numericValue": 0.05,
 "displayValue": "0.05"
 },
 "total-blocking-time": {
 "numericValue": 120,
 "displayValue": "120 ms"
 }
 }
 },
 "loadingExperience": {
 "metrics": {
 "LARGEST_CONTENTFUL_PAINT_MS": { "percentile": 2500 },
 "FIRST_INPUT_DELAY_MS": { "percentile": 100 }
 }
 }
}

The response includes performance scores on a scale of 0-100, with higher scores indicating better performance. It also provides detailed metrics such as Largest Contentful Paint (LCP), First Contentful Paint (FCP), and Cumulative Layout Shift (CLS). The category parameter can be extended to include accessibility, best practices, and SEO audits alongside performance analysis.

Setting Up Bulk Testing with Node.js

Node.js provides a practical environment for implementing bulk PageSpeed Insights testing. The following implementation demonstrates a complete workflow for testing multiple URLs with proper error handling and result aggregation.

Initial Project Setup

Create a new Node.js project and install necessary dependencies:

npm init -y
npm pkg set type="module"

The primary dependency is the built-in fetch API available in modern Node.js versions (v18+). No additional packages are required for basic functionality, though developers may add CSV parsing libraries for result export or use the node-csv package for advanced formatting.

Complete Implementation

The following code demonstrates a production-ready implementation with median calculation, error handling, and configurable parameters:

const API_URL = "https://www.googleapis.com/pagespeedonline/v5/runPagespeed";

// Configure API request with device strategy and categories
async function setUpQuery(url, device = 'mobile', apiKey = null) {
 const params = new URLSearchParams({
 url: url,
 strategy: device,
 category: 'performance'
 });
 
 if (apiKey) {
 params.append('key', apiKey);
 }
 
 return `${API_URL}?${params}`;
}

// Calculate median to reduce measurement variability
function calculateMedian(values) {
 const sorted = [...values].sort((a, b) => a - b);
 const mid = Math.floor(sorted.length / 2);
 return sorted.length % 2 !== 0 
 ? sorted[mid] 
 : (sorted[mid - 1] + sorted[mid]) / 2;
}

// Extract key performance metrics from API response
function extractMetrics(data) {
 const lighthouse = data.lighthouseResult;
 return {
 score: lighthouse.categories.performance.score * 100,
 lcp: lighthouse.audits['largest-contentful-paint'].numericValue,
 cls: lighthouse.audits['cumulative-layout-shift'].numericValue,
 tbt: lighthouse.audits['total-blocking-time'].numericValue,
 fcp: lighthouse.audits['first-contentful-paint'].numericValue,
 speedIndex: lighthouse.audits['speed-index'].numericValue
 };
}

// Main bulk test function
async function runBulkTest(urls, options = {}) {
 const { iterations = 3, device = 'mobile', apiKey = null, delay = 1000 } = options;
 const results = [];
 
 for (const url of urls) {
 const urlResults = [];
 
 for (let i = 0; i < iterations; i++) {
 try {
 const response = await fetch(await setUpQuery(url, device, apiKey));
 if (!response.ok) throw new Error(`HTTP ${response.status}`);
 const data = await response.json();
 urlResults.push(extractMetrics(data));
 } catch (error) {
 console.error(`Error testing ${url}:`, error.message);
 }
 
 // Rate limiting between iterations
 if (i < iterations - 1) await new Promise(r => setTimeout(r, delay));
 }
 
 if (urlResults.length > 0) {
 results.push({
 url,
 medianScore: calculateMedian(urlResults.map(r => r.score)),
 metrics: urlResults[Math.floor(urlResults.length / 2)],
 iterationsCompleted: urlResults.length
 });
 }
 }
 
 return results;
}

// Usage example
const urls = [
 "https://example.com/",
 "https://example.com/about",
 "https://example.com/services"
];

runBulkTest(urls, { iterations: 3, device: 'mobile' })
 .then(results => console.log(JSON.stringify(results, null, 2)));

Running multiple iterations per URL and calculating median values reduces variability inherent in web performance measurements. This approach provides more consistent results for comparison and tracking over time.

Configuring Test Parameters

Device Strategy Selection

The API supports two device strategies: mobile and desktop. Mobile strategy simulates a mid-range device on a 4G connection, while desktop strategy uses desktop conditions. Mobile scores are typically lower and more representative of real-world user experiences for most websites.

For comprehensive analysis, run tests with both strategies:

// Mobile testing (simulates 4G, mid-range device)
const mobileResults = await runBulkTest(urls, { iterations: 3, device: 'mobile' });

// Desktop testing (simulates desktop conditions)
const desktopResults = await runBulkTest(urls, { iterations: 3, device: 'desktop' });

Mobile results identify issues affecting the majority of users, while desktop results show optimal performance achievable on capable hardware. Prioritize mobile optimization since it provides broader user experience improvements.

Iteration Count and Median Calculation

Test each URL multiple times to account for measurement variability. Web performance can fluctuate based on network conditions, server load, and other transient factors. Running 3-5 iterations and using the median result provides more reliable data than single tests.

The median is preferred over the average because it is less affected by outliers. A single slow response can significantly skew the average, while the median remains representative of typical performance.

URL List Preparation

Prepare URL lists for bulk testing by exporting from various sources. Sitemaps provide comprehensive URL listings. Google Search Console offers CSV export of indexed pages. Crawling tools like Screaming Frog can generate URL lists for sites without sitemaps.

Example URL list format (urls.txt):

https://example.com/
https://example.com/about
https://example.com/services
https://example.com/blog
https://example.com/contact

Ensure URLs are complete with protocol (https://) and exclude duplicate or non-canonical versions to avoid redundant testing. For large sites, consider sampling strategies that ensure coverage of all page types and templates.

Interpreting Results and Identifying Issues

Common Performance Issues

The API response includes detailed audit results identifying specific issues. The audits object contains over 50 individual checks with explanations and recommendations. Common problems include:

Prioritization Framework

Not all performance issues carry equal weight. Prioritize fixes based on impact on Core Web Vitals metrics, since these directly affect SEO rankings. LCP improvements typically provide the most significant user experience benefit.

Prioritization workflow:

1. Group pages by score: Separate pages into green, orange, and red categories
2. Identify patterns: Look for systemic issues affecting multiple pages
3. Calculate impact: Multiply pages affected by severity score
4. Implement fixes: Start with high-impact, low-effort optimizations
5. Retest: Verify improvements and adjust approach

Group pages by template to identify patterns. If all blog posts have similar image compression issues, implement a site-wide image optimization solution rather than fixing individual pages. This approach maximizes ROI on optimization efforts.

Identifying Systemic vs. Isolated Issues

Use bulk testing data to distinguish between issues affecting many pages versus isolated problems. Systemic issues indicate template-level or infrastructure problems requiring architectural changes. Isolated issues may relate to specific page content and can be addressed individually or through content guidelines.

For organizations seeking comprehensive performance management, integrating bulk testing with technical SEO services ensures performance improvements align with broader search optimization goals.

Exporting and Analyzing Results

Bulk testing generates large datasets requiring proper export and analysis tools. Structured export formats enable further analysis, reporting, and integration with other systems.

CSV Export Format

Export results to CSV for analysis in spreadsheet applications. Include columns for URL, performance score, LCP, CLS, INP, and timestamp:

function exportToCSV(results) {
 const headers = ['URL', 'Score', 'LCP (ms)', 'CLS', 'INP (ms)', 'Timestamp'];
 const rows = results.map(r => [
 r.url,
 r.medianScore,
 r.metrics.lcp,
 r.metrics.cls,
 r.metrics.inp,
 new Date().toISOString()
 ]);
 
 return [headers, ...rows].map(row => row.join(',')).join('\n');
}

CSV exports enable filtering, sorting, and visualization in spreadsheet software. Use conditional formatting to highlight problematic pages. Create charts showing score distributions and improvement trends over time.

JSON Export for Processing

Export results to JSON for programmatic processing and integration with other tools. JSON format preserves full metric detail and is suitable for database storage or API integration.

function exportToJSON(results) {
 return JSON.stringify({
 generatedAt: new Date().toISOString(),
 summary: {
 totalPages: results.length,
 averageScore: calculateAverage(results.map(r => r.medianScore)),
 medianScore: calculateMedian(results.map(r => r.medianScore)),
 pagesNeedingImprovement: results.filter(r => r.medianScore < 90).length,
 pagesRequiringAttention: results.filter(r => r.medianScore < 50).length
 },
 pages: results
 }, null, 2);
}

JSON exports support automated analysis pipelines. Combine bulk test results with other data sources for comprehensive performance dashboards. Import into business intelligence tools for executive reporting and trend analysis.

Building Performance Dashboards

Use exported data to create ongoing performance monitoring dashboards. Track key metrics over time:

• Score distribution: Percentage of pages in each threshold category
• Trend lines: Average score changes week over week
• Metric breakdowns: Average LCP, CLS, INP across the site
• Template comparisons: Performance by page type or template

Set performance budgets based on industry benchmarks and internal goals. Trigger alerts when budgets are exceeded or significant regressions occur.

Best Practices for Bulk Testing

Rate Limiting and API Quotas

The PageSpeed Insights API has usage quotas that limit requests per day. For bulk testing, implement rate limiting to avoid exceeding quotas. Space requests evenly using delays between iterations and respect Google Cloud quota settings.

Consider testing a representative sample of pages rather than all URLs for large sites. Use site structure to ensure coverage of all page types and templates. Retest the full site after significant optimizations to verify improvements.

Consistent Testing Conditions

Run tests under consistent conditions for valid comparisons. Test at similar times of day to avoid network variability. Use the same device strategy (mobile or desktop) for trend analysis. Document test parameters and timestamps for reference and reproducibility.

Avoid testing during peak traffic periods when server response times may be elevated. Consider using scheduled tests during off-peak hours for baseline performance measurement that represents optimal conditions.

Integrating with Development Workflows

Embed bulk testing into continuous integration pipelines to catch performance regressions before deployment. Run tests against staging environments before production releases. Set performance budgets that fail builds if scores fall below thresholds.

Automate notification of significant performance changes. Integrate results with project management tools to create optimization tasks automatically when performance issues are detected. This ensures performance remains visible throughout development cycles.

Common Tools for Bulk PageSpeed Testing

Several tools support bulk PageSpeed Insights testing with varying features and capabilities. The right choice depends on your specific requirements, budget, and integration needs.

API-Based Solutions

Custom implementations using the PageSpeed Insights API offer maximum flexibility. Developers can customize testing parameters, result processing, and integration with existing workflows. The API supports both mobile and desktop testing with comprehensive metric output.

Third-Party Bulk Testing Tools

Commercial SEO platforms often include bulk PageSpeed testing features alongside other SEO capabilities. These tools typically offer additional metrics, historical tracking, and competitive analysis. Evaluate tools based on feature requirements, budget constraints, and integration needs.

Open-source bulk testing scripts provide starting points for custom implementations. Review available scripts to find those matching your requirements and extend them as needed.

Conclusion

Bulk PageSpeed Insights testing enables efficient, scalable performance monitoring for websites of any size. By automating performance analysis across multiple pages, development teams can identify issues systematically, prioritize optimizations effectively, and track improvement progress over time.

The PageSpeed Insights API provides comprehensive performance data including Core Web Vitals metrics essential for SEO success. Node.js implementations enable flexible bulk testing with customizable parameters and result processing. Following best practices for testing consistency and result analysis maximizes the value of bulk testing efforts.

Implementing bulk testing as part of regular performance management workflows ensures websites maintain optimal performance as they evolve. Use results to drive optimization priorities and demonstrate performance improvements to stakeholders. Regular bulk testing combined with our web development services helps maintain fast, user-friendly websites that rank well in search engines and convert visitors effectively.

For organizations seeking comprehensive performance management, consider integrating bulk testing with technical SEO services to ensure performance improvements align with broader search optimization goals.