# Node.js API 客户端
npm install googleapis
 
# Python 客户端
pip install google-api-python-client
 
# 或使用简单的 HTTP 请求（无需 SDK）
curl "https://www.googleapis.com/pagespeedonline/v5/runPagespeed?url=https://example.com"

# 基础请求
curl "https://www.googleapis.com/pagespeedonline/v5/runPagespeed?url=https://example.com&strategy=mobile"
 
# 使用 API Key
curl "https://www.googleapis.com/pagespeedonline/v5/runPagespeed?url=https://example.com&strategy=mobile&key=YOUR_API_KEY"
 
# 指定类别
curl "https://www.googleapis.com/pagespeedonline/v5/runPagespeed?url=https://example.com&category=performance&category=seo"

import fetch from 'node-fetch';
 
const PSI_API = 'https://www.googleapis.com/pagespeedonline/v5/runPagespeed';
 
async function analyzePage(url, strategy = 'mobile') {
  const params = new URLSearchParams({
    url,
    strategy,
    category: 'performance',
  });
 
  const response = await fetch(`${PSI_API}?${params}`);
  const data = await response.json();
 
  // 性能分数
  const perfScore = data.lighthouseResult?.categories?.performance?.score;
  console.log(`Performance Score: ${(perfScore * 100).toFixed(0)}`);
 
  // Core Web Vitals（实验室数据）
  const audits = data.lighthouseResult?.audits;
  console.log(`LCP: ${audits['largest-contentful-paint']?.displayValue}`);
  console.log(`CLS: ${audits['cumulative-layout-shift']?.displayValue}`);
  console.log(`TBT: ${audits['total-blocking-time']?.displayValue}`);
 
  // 真实用户数据（Field Data）
  const fieldData = data.loadingExperience?.metrics;
  if (fieldData) {
    console.log(`Real-user LCP: ${fieldData.LARGEST_CONTENTFUL_PAINT?.percentile}ms`);
    console.log(`Real-user INP: ${fieldData.INTERACTION_TO_NEXT_PAINT?.percentile}ms`);
    console.log(`Real-user CLS: ${fieldData.CUMULATIVE_LAYOUT_SHIFT?.percentile}`);
  }
 
  return data;
}
 
analyzePage('https://example.com');

import fetch from 'node-fetch';
 
const PSI_API = 'https://www.googleapis.com/pagespeedonline/v5/runPagespeed';
const API_KEY = process.env.PSI_API_KEY;
const DELAY_MS = 5000; // 避免触发限频
 
const urls = [
  'https://example.com/',
  'https://example.com/about',
  'https://example.com/blog',
];
 
async function batchAnalyze(urls) {
  const results = [];
 
  for (const url of urls) {
    console.log(`Analyzing: ${url}`);
    const params = new URLSearchParams({
      url,
      strategy: 'mobile',
      category: 'performance',
      key: API_KEY,
    });
 
    try {
      const response = await fetch(`${PSI_API}?${params}`);
      const data = await response.json();
      const score = data.lighthouseResult?.categories?.performance?.score;
 
      results.push({ url, score: Math.round(score * 100) });
    } catch (error) {
      console.error(`Error analyzing ${url}:`, error.message);
      results.push({ url, score: null, error: error.message });
    }
 
    // 请求间隔，避免限频
    await new Promise(resolve => setTimeout(resolve, DELAY_MS));
  }
 
  return results;
}
 
batchAnalyze(urls).then(console.log);

{
  "captchaResult": "NO_CAPTCHA",
  "kind": "pagespeedonline#pagespeedApiRunningResult",
  "lighthouseResult": { ... },     // Lighthouse 实验室数据
  "loadingExperience": { ... },     // 真实用户体验数据
  "originLoadingExperience": { ... }, // 站点级别真实数据
  "analysisUTCTimestamp": "...",
  "version": { "major": 5, "minor": 0 }
}

# GitHub Actions 示例
name: PageSpeed Insights Check
on:
  schedule:
    - cron: '0 0 * * 1'  # 每周一运行
  workflow_dispatch:
 
jobs:
  pagespeed:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - name: Run PageSpeed Insights
        env:
          PSI_API_KEY: ${{ secrets.PSI_API_KEY }}
        run: |
          URLS="https://example.com https://example.com/about"
          for url in $URLS; do
            SCORE=$(curl -s \
              "https://www.googleapis.com/pagespeedonline/v5/runPagespeed?url=$url&strategy=mobile&category=performance&key=$PSI_API_KEY" \
              | jq '.lighthouseResult.categories.performance.score * 100')
            echo "URL: $url | Score: $SCORE"
 
            if (( $(echo "$SCORE < 80" | bc -l) )); then
              echo "::warning::Performance score below 80 for $url"
            fi
          done

// 性能监控服务
import fetch from 'node-fetch';
 
class PSIMonitor {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://www.googleapis.com/pagespeedonline/v5/runPagespeed';
  }
 
  async check(url, strategy = 'mobile') {
    const params = new URLSearchParams({
      url,
      strategy,
      category: 'performance',
      key: this.apiKey,
    });
 
    const response = await fetch(`${this.baseUrl}?${params}`);
    if (!response.ok) {
      throw new Error(`PSI API error: ${response.status}`);
    }
 
    const data = await response.json();
    return {
      url,
      strategy,
      timestamp: new Date().toISOString(),
      performanceScore: data.lighthouseResult?.categories?.performance?.score,
      labMetrics: this.extractLabMetrics(data),
      fieldMetrics: this.extractFieldMetrics(data),
    };
  }
 
  extractLabMetrics(data) {
    const audits = data.lighthouseResult?.audits || {};
    return {
      lcp: audits['largest-contentful-paint']?.numericValue,
      tbt: audits['total-blocking-time']?.numericValue,
      cls: audits['cumulative-layout-shift']?.numericValue,
      fcp: audits['first-contentful-paint']?.numericValue,
      si: audits['speed-index']?.numericValue,
    };
  }
 
  extractFieldMetrics(data) {
    const metrics = data.loadingExperience?.metrics || {};
    return {
      lcp: metrics.LARGEST_CONTENTFUL_PAINT?.percentile,
      inp: metrics.INTERACTION_TO_NEXT_PAINT?.percentile,
      cls: metrics.CUMULATIVE_LAYOUT_SHIFT?.percentile,
    };
  }
}

// 定义性能预算
const budgets = {
  '/': { minScore: 90, maxLCP: 2500, maxCLS: 0.1 },
  '/blog/*': { minScore: 80, maxLCP: 3000, maxCLS: 0.15 },
  '/admin/*': { minScore: 70, maxLCP: 4000, maxCLS: 0.2 },
};
 
// 检查性能预算
function checkBudget(path, results) {
  const budget = budgets[path] || budgets['/*'];
  const violations = [];
 
  if (results.performanceScore * 100 < budget.minScore) {
    violations.push(`Score ${results.performanceScore * 100} < ${budget.minScore}`);
  }
  if (results.labMetrics.lcp > budget.maxLCP) {
    violations.push(`LCP ${results.labMetrics.lcp}ms > ${budget.maxLCP}ms`);
  }
 
  return violations;
}