使用Playwright模拟AI爬虫测试网站GEO友好度（完整脚本）

在生成引擎优化（GEO）的实践中，了解AI搜索引擎如何抓取、解析和理解你的网站内容至关重要。传统的SEO工具无法完全模拟AI爬虫的行为逻辑，因为AI爬虫不仅仅关注元数据和链接结构，更注重语义理解、内容质量和上下文关联性。本教程将手把手教你使用Playwright构建完整的AI爬虫模拟测试系统，从环境搭建到自动化报告生成，帮助你全面评估网站的GEO友好度，并提供了可直接运行的生产级代码示例。

通过本教程，你将学会如何模拟主流AI搜索引擎的抓取行为，检测页面的结构化数据完整性，评估内容的可读性和语义结构，分析JavaScript渲染对AI理解的影响，并最终生成一个全面的GEO友好度评分报告。无论你是技术SEO专家、前端开发者，还是GEO优化顾问，这套工具都能帮助你深入理解网站在AI眼中的表现，从而制定更有效的优化策略。

步骤1: 环境准备与Playwright基础配置

在开始构建AI爬虫模拟系统之前，我们需要搭建完整的开发环境。Playwright是一个强大的浏览器自动化工具，支持Chromium、Firefox和WebKit，能够精确模拟真实用户的浏览行为，包括JavaScript执行、网络请求拦截和页面交互。对于GEO测试而言，Playwright的价值在于它能够完全渲染现代前端框架（如React、Vue、Angular）生成的页面，捕捉动态加载的内容，并模拟AI爬虫可能使用的无头浏览器环境。首先，确保你的系统已安装Python 3.8+和Node.js 16+，然后我们通过pip安装Playwright的Python版本，并下载浏览器二进制文件。

安装完成后，我们需要创建一个项目结构，包含配置文件、测试脚本和报告生成模块。建议使用虚拟环境隔离依赖，避免与其他项目冲突。在项目根目录下创建config.py用于存储测试配置（如目标URL、等待超时、用户代理等），创建crawlers目录存放不同的爬虫模拟脚本，创建analyzers目录存放内容分析工具，创建reports目录存放生成的报告。这种模块化的设计使得系统易于扩展和维护，你可以随时添加新的爬虫类型或分析维度。

# 创建项目目录结构
mkdir geo_crawler_testing
cd geo_crawler_testing
python -m venv venv
source venv/bin/activate  # Windows使用: venv\Scripts\activate

# 安装依赖
pip install playwright beautifulsoup4 lxml pandas matplotlib seaborn
playwright install chromium  # 仅安装Chromium，减少下载量

# 项目结构
mkdir -p crawlers analyzers reports utils
touch config.py main.py

配置文件的设置至关重要，它决定了爬虫的行为特征。我们需要定义一个接近真实AI爬虫的用户代理字符串，设置合理的请求间隔以避免被目标服务器识别为恶意爬虫，并配置视口大小以模拟不同的设备类型。对于GEO测试，我们特别关注移动端视口，因为越来越多的AI搜索结果倾向于优先考虑移动友好的页面。此外，还需要配置网络请求拦截规则，阻止不必要的资源加载（如广告、跟踪脚本），加快测试速度的同时减少噪声。

• 安装Python 3.8+和Playwright库，配置虚拟环境隔离依赖
• 创建模块化项目结构，分离爬虫、分析器和报告生成逻辑
• 配置接近真实AI爬虫的用户代理和请求头，避免被反爬虫机制拦截
• 设置视口大小和设备的像素比，模拟移动端和桌面端的AI爬虫视角

步骤2: 理解AI爬虫的抓取逻辑与行为特征

要有效测试网站的GEO友好度，首先必须深入理解AI爬虫与传统搜索引擎爬虫的本质区别。传统爬虫（如Googlebot）主要关注页面的元数据、链接结构和关键词密度，而AI爬虫（如ChatGPT的WebPilot、Perplexity的爬虫、Bing的AI爬虫）则采用更先进的语义理解技术。它们会执行页面的JavaScript代码，渲染完整的DOM树，然后使用自然语言处理模型分析页面内容的主题、情感、实体关系和可信度。AI爬虫还会关注页面的E-E-A-T信号（经验、专业、权威、可信），包括作者信息、引用来源、外部链接质量和页面更新的频率。

通过逆向工程和公开文档分析，我们发现主流AI爬虫通常遵循以下抓取逻辑：首先请求页面HTML，然后并行加载关键资源（CSS、JavaScript、图片），等待网络空闲或超时后捕获渲染后的页面内容。它们会优先抓取语义化标签（如<article>、<main>、<header>）中的内容，忽略导航、侧边栏和页脚中的非核心内容。AI爬虫还会检测页面的结构化数据（Schema.org、Open Graph、Twitter Cards），并将其作为理解页面主题的重要信号。此外，它们会评估页面的可读性（使用Flesch-Kincaid等算法）和内容的独特性，避免收录重复或低质量的内容。

# analyzers/crawler_behavior.py
from playwright.sync_api import sync_playwright
import json

def analyze_crawler_accessibility(url):
    """分析页面对于AI爬虫的可访问性"""
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page(
            user_agent='Mozilla/5.0 (compatible; AITestBot/1.0; +http://example.com/bot)'
        )
        
        # 监听网络请求，分析资源加载模式
        requests = []
        page.on('request', lambda req: requests.append({
            'url': req.url,
            'method': req.method,
            'type': req.resource_type
        }))
        
        page.goto(url, wait_until='networkidle')
        
        # 检测关键SEO元素
        seo_data = page.evaluate('''() => {
            return {
                title: document.title,
                metaDescription: document.querySelector('meta[name="description"]')?.content,
                h1Count: document.querySelectorAll('h1').length,
                canonical: document.querySelector('link[rel="canonical"]')?.href,
                robotsMeta: document.querySelector('meta[name="robots"]')?.content
            };
        }''')
        
        browser.close()
        return {'requests': requests, 'seo': seo_data}

为了更精确地模拟AI爬虫，我们还需要考虑它们对页面性能的敏感度。虽然AI爬虫不像人类用户那样关注页面加载速度，但过慢的服务器响应或大量的第三方脚本可能会阻止爬虫完整渲染页面。我们通过Playwright的performance API收集页面加载的详细时间线，包括DNS查询、TCP连接、DOM解析、资源加载等关键指标。这些数据将帮助我们识别可能影响AI爬虫抓取的技术障碍，如未优化的图片、阻塞渲染的CSS、或过重的JavaScript框架。

• AI爬虫执行JavaScript并渲染完整DOM，不同于传统爬虫仅解析初始HTML
• 优先抓取语义化标签内容，使用NLP模型分析主题和实体关系
• 评估E-E-A-T信号：作者信息、引用来源、外部链接质量
• 检测结构化数据（Schema.org、OG、Twitter Cards）作为理解页面的辅助信号
• 关注页面性能对完整渲染的影响，识别技术障碍

步骤3: 编写基础爬虫模拟脚本与页面内容提取

现在我们来编写核心的爬虫模拟脚本，该脚本将模拟AI爬虫的行为，访问目标页面并提取对GEO至关重要的内容元素。我们使用Playwright的Python API创建一个可配置的爬虫类，支持设置用户代理、视口大小、等待策略和提取规则。脚本的核心功能是等待页面完全渲染后，使用JavaScript注入的方式提取页面的文本内容、标题层级、链接结构、图片alt属性等关键信息。这些信息将作为后续GEO分析的基础数据。

在内容提取策略上，我们需要模拟AI爬虫对页面结构的理解方式。AI爬虫通常使用机器学习模型识别页面的主要内容和辅助内容，而不是简单地依赖CSS选择器。为了提高模拟的准确性，我们实现了基于视觉特征和DOM结构的双重内容提取算法：首先使用Readability.js（一个开源的文章内容提取库）识别页面的核心内容区域，然后结合语义化标签（如article、main）和WAI-ARIA属性进行验证。这种混合方法能够更准确地模拟AI爬虫如何”阅读”页面，避免将导航菜单、广告侧边栏等噪声内容误判为页面主题。

# crawlers/ai_crawler.py
from playwright.sync_api import sync_playwright
from bs4 import BeautifulSoup
import json

class AICrawler:
    def __init__(self, headless=True, viewport_width=1280, viewport_height=720):
        self.headless = headless
        self.viewport = {'width': viewport_width, 'height': viewport_height}
        self.user_agent = 'Mozilla/5.0 (compatible; AISearchBot/2.0; +https://example.com/bot)'
    
    def crawl(self, url, wait_strategy='networkidle'):
        """模拟AI爬虫抓取页面"""
        with sync_playwright() as p:
            browser = p.chromium.launch(headless=self.headless)
            context = browser.new_context(
                viewport=self.viewport,
                user_agent=self.user_agent
            )
            page = context.new_page()
            
            # 注入Readability.js以提取核心内容
            page.add_init_script(path='./utils/readability.js')
            
            page.goto(url, wait_until=wait_strategy, timeout=30000)
            
            # 提取页面数据
            page_data = page.evaluate('''() => {
                const reader = new Readability(window.document.cloneNode(true));
                const article = reader.parse();
                return {
                    title: document.title,
                    url: window.location.href,
                    canonicalUrl: document.querySelector('link[rel="canonical"]')?.href,
                    metaDescription: document.querySelector('meta[name="description"]')?.content || '',
                    ogTitle: document.querySelector('meta[property="og:title"]')?.content || '',
                    ogDescription: document.querySelector('meta[property="og:description"]')?.content || '',
                    articleContent: article ? article.content : document.body.innerHTML,
                    articleText: article ? article.textContent : document.body.innerText,
                    headings: Array.from(document.querySelectorAll('h1,h2,h3')).map(h => ({
                        tag: h.tagName.toLowerCase(),
                        text: h.innerText.trim()
                    })),
                    links: Array.from(document.querySelectorAll('a[href]')).map(a => ({
                        href: a.href,
                        text: a.innerText.trim(),
                        isExternal: !a.href.includes(window.location.hostname)
                    })),
                    images: Array.from(document.querySelectorAll('img[src]')).map(img => ({
                        src: img.src,
                        alt: img.alt || '',
                        hasAlt: !!img.alt
                    }))
                };
            }''')
            
            browser.close()
            return page_data

为了处理现代网站常见的大量异步加载内容（如无限滚动、懒加载图片、动态插入的模块），我们需要在爬虫脚本中实现智能等待机制。简单的固定时间等待（如time.sleep）既不可靠也效率低下。Playwright提供了多种等待策略：等待特定DOM元素出现、等待网络请求完成、等待函数返回true等。我们结合使用这些策略，首先等待页面的主要布局元素（如main、article）加载完成，然后等待所有带有lazy-loading属性的图片加载完成，最后等待任何可能的AJAX请求完成。通过监听page.on(‘response’)事件，我们可以追踪所有网络请求的完成状态，确保页面完全渲染后再提取内容。

• 创建可配置的AICrawler类，支持自定义用户代理、视口和等待策略
• 使用Readability.js识别核心内容区域，模拟AI爬虫的内容理解方式
• 提取关键GEO元素：标题层级、链接结构、图片alt属性、元数据结构
• 实现智能等待机制，处理异步加载内容和懒加载资源
• 返回结构化的页面数据，为后续分析提供完整的信息基础

步骤4: 检测页面结构化数据与语义标记完整性

结构化数据是AI搜索引擎理解页面内容最重要的信号之一。Schema.org标记、Open Graph协议和Twitter Cards不仅帮助社交媒体平台正确展示页面，更是AI爬虫提取实体信息、关系和时间线的基础数据源。在本步骤中，我们将编写一个专门的分析器，检测页面中结构化数据的完整性、正确性和覆盖范围。分析器会检查Schema.org的JSON-LD、Microdata和RDFa三种格式，验证必需属性是否存在，检测数据类型是否正确，并评估结构化数据的深度（是否仅标记了基础信息，还是包含了详细的专业信息如作者、发布日期、评分等）。

对于GEO优化而言，不同类型的页面需要不同的Schema.org标记。文章页面应使用Article或BlogPosting类型，包含headline、datePublished、dateModified、author、publisher等属性；产品页面应使用Product类型，包含name、description、brand、offers、review等属性；FAQ页面应使用FAQPage类型，包含mainEntity属性。我们的分析器会首先识别页面类型（通过URL模式、页面内容或明确的Schema标记），然后检查对应的必需属性是否完整。此外，我们还会检测页面是否同时使用多种结构化数据格式（如同时有JSON-LD和Meta标签），这可能导致AI爬虫理解冲突，降低页面的GEO效果。

# analyzers/structured_data.py
import json
from bs4 import BeautifulSoup

class StructuredDataAnalyzer:
    def __init__(self, page_html, page_url):
        self.soup = BeautifulSoup(page_html, 'lxml')
        self.url = page_url
        self.results = {
            'json_ld': [],
            'microdata': [],
            'opengraph': {},
            'twitter_cards': {},
            'issues': []
        }
    
    def analyze_json_ld(self):
        """分析JSON-LD结构化数据"""
        scripts = self.soup.find_all('script', type='application/ld+json')
        for script in scripts:
            try:
                data = json.loads(script.string)
                self.results['json_ld'].append(data)
                
                # 检查必需属性
                if isinstance(data, dict):
                    schema_type = data.get('@type', '')
                    self._validate_schema_properties(data, schema_type)
            except json.JSONDecodeError:
                self.results['issues'].append('Invalid JSON-LD format')
        
        return self.results['json_ld']
    
    def _validate_schema_properties(self, data, schema_type):
        """验证Schema.org属性的完整性"""
        required_props = {
            'Article': ['headline', 'datePublished', 'author'],
            'Product': ['name', 'description', 'offers'],
            'FAQPage': ['mainEntity'],
            'Organization': ['name', 'url'],
            'Person': ['name']
        }
        
        if schema_type in required_props:
            for prop in required_props[schema_type]:
                if prop not in data:
                    self.results['issues'].append(
                        f'Missing required property "{prop}" for {schema_type}'
                    )
    
    def analyze_opengraph(self):
        """分析Open Graph协议标记"""
        og_tags = self.soup.find_all('meta', property=lambda x: x and x.startswith('og:'))
        for tag in og_tags:
            property_name = tag.get('property', '').replace('og:', '')
            self.results['opengraph'][property_name] = tag.get('content', '')
        
        # 检查必需的OG属性
        required_og = ['title', 'type', 'image', 'url']
        for prop in required_og:
            if prop not in self.results['opengraph']:
                self.results['issues'].append(f'Missing og:{prop} meta tag')
        
        return self.results['opengraph']

除了检测结构化数据是否存在，我们还需要评估其质量和覆盖范围。一个常见的GEO优化错误是仅添加最基础的结构化数据（如仅标记了页面类型和企业名称），而忽略了能够提供丰富上下文的高级属性。例如，对于一篇文章，除了基本的headline和datePublished，还应该标记author的详细信息和publisher的logo；对于产品，除了name和description，还应该标记aggregateRating、review和offers的详细价格信息。我们的分析器会生成一个”结构化数据丰富度评分”，评估页面是否充分利用了Schema.org的词汇表，并给出具体的改进建议。

• 检测JSON-LD、Microdata和RDFa三种格式的结构化数据
• 验证Schema.org类型的必需属性是否完整（Article、Product、FAQPage等）
• 分析Open Graph和Twitter Cards标记的完整性
• 评估结构化数据的丰富度和覆盖范围，生成改进建议
• 检测多种格式并存可能导致的理解冲突

步骤5: 评估内容可读性与语义结构优化程度

内容的可读性和语义结构直接影响AI爬虫对页面主题的理解深度。AI搜索引擎使用先进的自然语言处理模型（如BERT、GPT）分析页面内容的语义密度、主题一致性和信息层次。在本步骤中，我们将构建一个内容质量评估系统，从多个维度分析页面的文本内容：阅读难度（使用Flesch Reading Ease等算法）、句子和段落长度分布、标题层级的逻辑性、关键词的语义相关性，以及内容是否与页面的核心主题保持一致。这些指标将帮助我们识别可能影响GEO效果的内容结构问题。

实现这个分析器的关键技术挑战在于准确分词和语义理解。对于中文内容，我们使用jieba进行分词，然后结合预训练的中文语言模型（如BERT-base-Chinese）计算文本的语义向量，评估段落之间的主题一致性。对于英文内容，我们使用NLTK进行分词和词性标注，然后使用TextStat库计算各种可读性指标。此外，我们还会分析标题层级（H1-H6）的使用是否合理：H1是否唯一且包含核心关键词，H2是否清晰划分内容章节，H3是否作为H2的逻辑子节点。一个语义结构良好的页面应该像一篇组织良好的文章，有清晰的信息层次和逻辑流动。

# analyzers/content_analyzer.py
import re
from collections import Counter
from bs4 import BeautifulSoup

class ContentQualityAnalyzer:
    def __init__(self, html_content, text_content):
        self.soup = BeautifulSoup(html_content, 'lxml')
        self.text = text_content
        self.metrics = {}
    
    def analyze_readability(self):
        """分析内容可读性（英文示例，中文需使用不同算法）"""
        # 计算基本统计
        sentences = re.split(r'[.!?]+', self.text)
        words = self.text.split()
        
        avg_sentence_length = len(words) / len(sentences) if sentences else 0
        avg_word_length = sum(len(w) for w in words) / len(words) if words else 0
        
        # Flesch Reading Ease (简化版，适用于英文)
        if avg_sentence_length > 0:
            fre_score = 206.835 - (1.015 * avg_sentence_length) - (84.6 * avg_word_length / 4.7)
        else:
            fre_score = 0
        
        self.metrics['readability'] = {
            'flesch_score': round(fre_score, 2),
            'avg_sentence_length': round(avg_sentence_length, 2),
            'avg_word_length': round(avg_word_length, 2),
            'total_sentences': len(sentences),
            'total_words': len(words)
        }
        return self.metrics['readability']
    
    def analyze_heading_structure(self):
        """分析标题层级结构"""
        headings = self.soup.find_all(['h1', 'h2', 'h3', 'h4', 'h5', 'h6'])
        structure = []
        issues = []
        
        for i, h in enumerate(headings):
            tag = h.name
            text = h.get_text().strip()
            structure.append({'level': int(tag[1]), 'text': text})
            
            # 检查H1唯一性
            if tag == 'h1':
                h1_count = len(self.soup.find_all('h1'))
                if h1_count > 1:
                    issues.append(f'Multiple H1 tags found ({h1_count})')
            
            # 检查层级跳跃
            if i > 0:
                prev_level = structure[i-1]['level']
                curr_level = int(tag[1])
                if curr_level > prev_level + 1:
                    issues.append(f'Heading level jump from H{prev_level} to H{curr_level}')
        
        self.metrics['heading_structure'] = {
            'headings': structure,
            'issues': issues,
            'has_logical_flow': len(issues) == 0
        }
        return self.metrics['heading_structure']
    
    def analyze_content_density(self, target_keywords):
        """分析关键词密度和语义相关性"""
        text_lower = self.text.lower()
        keyword_counts = {}
        
        for keyword in target_keywords:
            count = text_lower.count(keyword.lower())
            density = (count / len(self.text.split())) * 100 if self.text else 0
            keyword_counts[keyword] = {
                'count': count,
                'density': round(density, 2)
            }
        
        self.metrics['keyword_density'] = keyword_counts
        return keyword_counts

为了更全面地评估内容的GEO友好度，我们的分析器还会检测内容的”实体密度”和”主题覆盖度”。实体密度指的是页面中提到的具有明确语义的实体（如人名、地名、组织名、产品名）的数量和分布；主题覆盖度指的是页面内容是否全面覆盖了目标主题的各个重要方面。我们通过调用公开的自然语言API（如Google Cloud Natural Language API、Azure Text Analytics）或使用本地部署的模型（如spaCy、Stanford CoreNLP）来提取页面中的命名实体，然后与行业标准知识图谱（如Wikidata、DBpedia）进行匹配，评估实体的权威性和相关性。这种分析能够帮助我们发现内容中的知识缺口，指导后续的内容优化工作。

• 评估内容可读性：句子长度、段落结构、Flesch评分（中英文分别处理）
• 分析标题层级逻辑性：H1唯一性、层级跳跃检测、语义连贯性
• 计算关键词密度和分布，避免关键词堆砌或密度过低
• 检测命名实体密度和主题覆盖度，评估内容的语义丰富性
• 生成内容质量评分和改进建议报告

步骤6: 检测页面加载性能与JavaScript渲染兼容性

页面的加载性能和JavaScript渲染兼容性对GEO有着重要影响。虽然AI爬虫比传统爬虫更擅长执行JavaScript，但它们仍然受到时间预算和计算资源的限制。如果页面的关键内容需要大量JavaScript执行或多次网络请求才能显示，AI爬虫可能会放弃等待或仅捕获部分内容。在本步骤中，我们将使用Playwright的性能分析功能，详细检测页面的加载时间线、资源大小、JavaScript执行耗时，以及不同网络条件下的渲染表现。这些数据将帮助我们识别可能阻碍AI爬虫完整理解页面的性能瓶颈。

我们使用Playwright的cdp_session（Chrome DevTools Protocol会话）来收集底层的性能数据。通过CDP，我们可以访问浏览器内核的性能指标，如首次内容绘制（FCP）、最大内容绘制（LCP）、累积布局偏移（CLS）等Core Web Vitals指标。对于GEO测试，我们特别关注”内容可访问时间”（Time to Content Accessibility, TTCA）——即页面的核心内容（文章正文、产品信息、FAQ答案）完全渲染并可被DOM查询到的时间点。如果TTCA超过3秒，AI爬虫可能会认为页面内容加载不可靠，降低页面的索引优先级。我们还会模拟不同的网络条件（如慢速3G、快速4G），测试页面在较差网络环境下的表现。

# analyzers/performance_analyzer.py
from playwright.sync_api import sync_playwright
import json

class PerformanceAnalyzer:
    def __init__(self, url):
        self.url = url
        self.metrics = {}
    
    def analyze_loading_performance(self, network_condition='default'):
        """分析页面加载性能"""
        with sync_playwright() as p:
            browser = p.chromium.launch(headless=True)
            context = browser.new_context()
            
            # 模拟网络条件
            if network_condition == 'slow3g':
                context = browser.new_context(
                    viewport={'width': 1280, 'height': 720},
                    user_agent='Mozilla/5.0 (compatible; AISearchBot/2.0)'
                )
                # 注意：Playwright Python API不直接支持网络节流，需要使用CDP
            
            page = context.new_page()
            
            # 收集性能指标
            client = page.context.new_cdp_session(page)
            client.send('Performance.enable')
            
            # 监听性能条目
            performance_entries = []
            def handle_metrics(event):
                performance_entries.append(event)
            
            page.on('response', lambda response: self._log_response(response))
            
            page.goto(self.url, wait_until='networkidle', timeout=30000)
            
            # 获取性能时间线
            timing = page.evaluate('''() => {
                const perf = window.performance.timing;
                return {
                    domContentLoaded: perf.domContentLoadedEventEnd - perf.navigationStart,
                    fullyLoaded: perf.loadEventEnd - perf.navigationStart,
                    dnsLookup: perf.domainLookupEnd - perf.domainLookupStart,
                    tcpConnect: perf.connectEnd - perf.connectStart,
                    serverResponse: perf.responseStart - perf.requestStart,
                    domParsing: perf.domInteractive - perf.domLoading
                };
            }''')
            
            # 使用Core Web Vitals库评估
            web_vitals = page.evaluate('''() => {
                return new Promise((resolve) => {
                    // 简化版：实际应用中应使用web-vitals库
                    const vitals = {};
                    new PerformanceObserver((list) => {
                        for (const entry of list.getEntries()) {
                            if (entry.name === 'LCP') vitals.lcp = entry.startTime;
                            if (entry.name === 'FCP') vitals.fcp = entry.startTime;
                        }
                        resolve(vitals);
                    }).observe({entryTypes: ['largest-contentful-paint', 'first-contentful-paint']});
                });
            }''')
            
            self.metrics = {
                'timing': timing,
                'web_vitals': web_vitals,
                'total_size': self._calculate_page_size(page)
            }
            
            browser.close()
            return self.metrics
    
    def _log_response(self, response):
        """记录所有网络响应"""
        # 在实际应用中，这里会存储响应数据用于分析
        pass
    
    def _calculate_page_size(self, page):
        """计算页面总大小"""
        # 通过CDP获取所有资源的字节数
        # 简化实现
        return 0

除了性能指标，我们还需要检测页面是否存在JavaScript渲染相关的GEO问题。常见的问题包括：核心内容仅通过客户端JavaScript渲染（导致无JavaScript环境的爬虫无法看到）、依赖用户交互才能显示的内容（如点击”显示更多”按钮）、使用JavaScript动态修改meta标签（搜索引擎可能看不到最终值）、以及严重的客户端错误（如JavaScript异常阻止了内容渲染）。我们的检测脚本会捕获页面的所有JavaScript异常，检查核心内容是否在初始HTML中可用（或通过服务器端渲染提供），并模拟禁用JavaScript后的页面表现。这种全面的兼容性测试能够确保页面在各种爬虫环境下都能被正确理解和索引。

• 使用Playwright CDP会话收集详细的性能指标（FCP、LCP、CLS等）
• 测量”内容可访问时间”(TTCA)，确保核心内容快速可访问
• 模拟不同网络条件，测试页面在慢速网络下的GEO兼容性
• 检测JavaScript渲染问题：客户端渲染依赖、动态内容加载、JS异常
• 模拟禁用JavaScript的爬虫视角，确保核心内容仍可访问

步骤7: 生成GEO友好度综合评分报告

在完成了结构化数据检测、内容质量分析和性能评估后，我们需要将所有的分析结果汇总成一个综合的GEO友好度评分报告。这个报告不仅仅是简单的分数展示，更应该是一个可操作的优化指南。我们设计一个加权评分系统，根据不同因素对GEO的影响程度分配权重：结构化数据完整性（25%）、内容质量和语义结构（35%）、页面性能和渲染兼容性（20%）、技术SEO基础（15%）、移动友好度（5%）。每个维度都会生成一个0-100的子分数，然后根据权重计算总体GEO分数（0-100）。

报告生成模块使用Python的Jinja2模板引擎创建可视化的HTML报告，包含分数仪表盘、问题优先级列表、详细检测结果和具体改进建议。我们还会生成适合机器读取的JSON格式报告，方便集成到CI/CD流水线或监控系统中。报告的一个关键特性是”竞品对比”功能：用户可以指定3-5个竞争对手的URL，系统会自动抓取并分析这些页面，然后在报告中并排展示你的页面与竞品的GEO评分对比。这种对比分析能够直观地展示你在哪些GEO维度上领先或落后，从而指导优化资源的分配。

# reports/report_generator.py
from jinja2 import Template
import json
from datetime import datetime

class GEOReportGenerator:
    def __init__(self, analysis_results):
        self.results = analysis_results
        self.report_data = {
            'score': 0,
            'dimensions': {},
            'issues': [],
            'recommendations': []
        }
    
    def calculate_geo_score(self):
        """计算综合GEO友好度评分"""
        weights = {
            'structured_data': 0.25,
            'content_quality': 0.35,
            'performance': 0.20,
            'technical_seo': 0.15,
            'mobile_friendly': 0.05
        }
        
        scores = {}
        
        # 结构化数据评分
        sd_issues = len(self.results.get('structured_data', {}).get('issues', []))
        sd_score = max(0, 100 - sd_issues * 10)
        scores['structured_data'] = sd_score
        
        # 内容质量评分
        readability = self.results.get('content', {}).get('readability', {})
        heading_issues = len(self.results.get('content', {}).get('heading_structure', {}).get('issues', []))
        content_score = max(0, 100 - heading_issues * 5 - (100 - readability.get('flesch_score', 50)))
        scores['content_quality'] = content_score
        
        # 性能评分
        perf = self.results.get('performance', {})
        lcp = perf.get('web_vitals', {}).get('lcp', 0)
        perf_score = max(0, 100 - (lcp / 100) if lcp else 50)
        scores['performance'] = perf_score
        
        # 计算加权总分
        total_score = sum(scores[dim] * weights[dim] for dim in weights if dim in scores)
        self.report_data['score'] = round(total_score, 2)
        self.report_data['dimensions'] = scores
        
        return self.report_data
    
    def generate_html_report(self, output_path):
        """生成可视化HTML报告"""
        template_str = '''
        
        
        
            
            
        
        
            
GEO友好度分析报告
            
生成时间: {{ timestamp }}
            
分析URL: {{ url }}
            
            

                
总体评分: {{ report.score }}/100
                {% for dim, score in report.dimensions.items() %}
                

                    {{ dim }}: {{ score }}/100
                    

                        

                    
                
                {% endfor %}
            
            
            
检测到的问题 ({{ report.issues|length }})
            {% for issue in report.issues %}
            
{{ issue }}
            {% endfor %}
            
            
改进建议
            {% for rec in report.recommendations %}
            
{{ rec }}
            {% endfor %}
        
        
        '''
        
        template = Template(template_str)
        html_content = template.render(
            report=self.report_data,
            url=self.results.get('url', ''),
            timestamp=datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        )
        
        with open(output_path, 'w', encoding='utf-8') as f:
            f.write(html_content)
        
        return output_path

报告的核心价值在于提供具体、可操作的改进建议。我们不只告诉用户”你的页面GEO评分是65分”，而是要详细说明”为什么是65分”以及”如何提高到85分”。对于每个检测到的问题，我们都会提供优先级评级（高、中、低）、预期 impact（对GEO评分的提升幅度）、具体的修复步骤，以及参考示例代码或配置。例如，如果检测到页面缺少JSON-LD结构化数据，我们会提供针对该页面类型的JSON-LD模板代码，并说明应该填充哪些具体信息。这种”诊断+治疗”一体化的报告才能真正帮助用户提升网站的GEO表现。

• 设计加权评分系统：结构化数据(25%)、内容质量(35%)、性能(20%)、技术SEO(15%)、移动友好(5%)
• 生成可视化HTML报告，包含分数仪表盘、问题列表和改进建议
• 支持竞品对比功能，并排展示GEO评分差异
• 提供具体可操作的改进建议，包括优先级、预期影响和修复步骤
• 生成机器可读的JSON格式报告，支持CI/CD集成

步骤8: 自动化批量测试与CI/CD集成

单个页面的GEO测试只是开始，真正的价值在于能够持续监控整个网站的GEO健康度。在本步骤中，我们将把前面开发的各个模块整合成一个自动化批量测试系统，支持定期扫描网站的所有重要页面（通过sitemap.xml发现或手动指定URL列表），并将测试结果存储到数据库中，形成GEO表现的时间序列数据。这种历史数据能够帮助我们识别GEO评分的趋势（上升、下降或波动），及时发现因网站改版、内容更新或技术问题导致的GEO性能退化。

CI/CD集成是自动化测试系统的关键应用场景。我们可以在代码部署前（pre-deploy）自动运行GEO测试，如果检测到GEO评分低于预设阈值（如低于70分）或有新的严重问题（如结构化数据格式错误、H1标签缺失），则阻止部署并通知开发团队。这种”GEO即代码”(GEO-as-Code)的实践能够将GEO优化从被动的事后分析转变为主动的预防性措施。我们使用Python的APScheduler库实现定时任务调度，使用SQLAlchemy作为ORM层与数据库交互，使用Celery处理耗时的异步测试任务（如需要等待页面完全渲染的性能测试）。

# main.py - 主程序入口，支持批量测试和CI/CD集成
import sys
from crawlers.ai_crawler import AICrawler
from analyzers.structured_data import StructuredDataAnalyzer
from analyzers.content_analyzer import ContentQualityAnalyzer
from analyzers.performance_analyzer import PerformanceAnalyzer
from reports.report_generator import GEOReportGenerator
from utils.url_discovery import discover_urls_from_sitemap
import json

def run_geo_test(url, output_dir='./reports'):
    """运行完整的GEO测试流程"""
    print(f'开始测试: {url}')
    
    # 步骤1: 爬取页面
    crawler = AICrawler(headless=True)
    page_data = crawler.crawl(url)
    
    if not page_data:
        print(f'错误: 无法抓取 {url}')
        return None
    
    # 步骤2: 分析结构化数据
    sd_analyzer = StructuredDataAnalyzer(page_data['articleContent'], url)
    sd_results = {
        'json_ld': sd_analyzer.analyze_json_ld(),
        'opengraph': sd_analyzer.analyze_opengraph(),
        'issues': sd_analyzer.results['issues']
    }
    
    # 步骤3: 分析内容质量
    content_analyzer = ContentQualityAnalyzer(
        page_data['articleContent'],
        page_data['articleText']
    )
    content_results = {
        'readability': content_analyzer.analyze_readability(),
        'heading_structure': content_analyzer.analyze_heading_structure(),
        'keyword_density': content_analyzer.analyze_content_density([])
    }
    
    # 步骤4: 分析性能
    perf_analyzer = PerformanceAnalyzer(url)
    perf_results = perf_analyzer.analyze_loading_performance()
    
    # 步骤5: 生成报告
    all_results = {
        'url': url,
        'structured_data': sd_results,
        'content': content_results,
        'performance': perf_results
    }
    
    report_gen = GEOReportGenerator(all_results)
    report_gen.calculate_geo_score()
    report_path = report_gen.generate_html_report(f'{output_dir}/report_{url.replace("/", "_")}.html')
    
    print(f'测试完成: {url}')
    print(f'GEO评分: {report_gen.report_data["score"]}/100')
    print(f'报告已保存: {report_path}')
    
    return report_gen.report_data

def batch_test(urls, output_dir='./reports'):
    """批量测试多个URL"""
    results = []
    for url in urls:
        try:
            result = run_geo_test(url, output_dir)
            results.append(result)
        except Exception as e:
            print(f'测试 {url} 时出错: {str(e)}')
            results.append({'url': url, 'error': str(e)})
    
    # 生成汇总报告
    summary = {
        'total_urls': len(urls),
        'successful': len([r for r in results if r and 'error' not in r]),
        'average_score': sum(r['score'] for r in results if r and 'score' in r) / len(results),
        'results': results
    }
    
    with open(f'{output_dir}/summary.json', 'w', encoding='utf-8') as f:
        json.dump(summary, f, ensure_ascii=False, indent=2)
    
    return summary

if __name__ == '__main__':
    # 从命令行参数或配置文件读取URL列表
    if len(sys.argv) > 1:
        url = sys.argv[1]
        run_geo_test(url)
    else:
        # 从sitemap发现URL
        sitemap_url = 'https://example.com/sitemap.xml'
        urls = discover_urls_from_sitemap(sitemap_url)
        print(f'从sitemap发现 {len(urls)} 个URL')
        batch_test(urls[:10])  # 限制测试前10个URL

为了支持团队协作和结果追踪，我们还会构建一个简单的Web仪表盘，使用Flask或FastAPI框架，展示所有测试的GEO评分历史、问题分布热力图、改进建议跟踪状态等。团队成员可以在仪表盘上查看自己负责页面的GEO表现，分配优化任务，并记录修复进度。这种系统化的GEO管理流程能够确保优化工作持续进行，而不是一次性的项目。通过将GEO测试自动化并集成到日常开发流程中，我们能够建立起持续优化的文化，确保网站在长期运营中始终保持对AI搜索引擎的友好度。

• 整合所有分析模块，构建端到端的自动化GEO测试流水线
• 支持从sitemap自动发现URL，实现全站GEO健康度监控
• 集成到CI/CD流程，部署前自动检测GEO回归问题
• 存储历史数据，追踪GEO评分趋势和优化效果
• 构建Web仪表盘，支持团队协作和任务跟踪

避坑指南与进阶优化策略

在实践Playwright模拟AI爬虫测试的过程中，有几个常见的陷阱需要特别注意。首先，避免过于频繁的爬取请求，这可能触发目标网站的反爬虫机制，导致IP被封禁或法律纠纷。建议在生产环境中使用代理池、随机等待时间和请求限流。其次，Playwright的headless模式虽然高效，但某些网站会检测navigator.webdriver属性并阻止访问，需要使用stealth插件或自定义JavaScript绕过检测。第三，确保正确配置等待策略：等待networkidle可能不够准确（某些网站的统计脚本会持续发送请求），更好的做法是等待特定选择器出现或特定网络请求完成。

进阶优化方面，我们可以考虑引入机器学习模型来提升测试的准确性。例如，训练一个二分类模型来预测页面内容是否被AI爬虫正确理解，特征包括DOM结构、文本统计、链接关系等。我们还可以使用计算机视觉技术（通过截图和OCR）来验证页面的视觉呈现与代码描述是否一致（检测CLS问题）。另一个有价值的扩展是构建”AI爬虫友好度基准测试套件”，包含一系列精心设计的测试页面，每个页面测试一个特定的GEO因素（如JavaScript渲染、懒加载、动态内容），帮助用户快速诊断自己网站在特定方面的表现。最后，考虑将测试系统容器化（Docker），方便在不同环境中部署和运行，也便于开源社区贡献和协作。

性能优化也是实际应用中的重要考虑。当需要测试大量页面时，串行的Playwright脚本会非常慢。我们可以使用Playwright的context复用功能（在同一个浏览器实例中创建多个隔离的上下文）来实现并发测试，或者使用分布式任务队列（如Celery + Redis）将测试任务分配到多台机器上执行。此外，合理使用缓存（如将已爬取的页面内容缓存到本地或CDN）能够显著减少重复测试和开发调试的时间。对于持续的监控场景，可以使用Playwright的录制功能（codegen）来快速创建特定页面的测试脚本，然后定期运行这些脚本检测页面是否发生了意外的GEO回归。

# utils/optimization_tips.py
# 避坑指南代码片段

# 1. 使用stealth插件绕过反爬虫检测
from playwright.sync_api import sync_playwright
def stealth_browser():
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        # 注入stealth脚本隐藏自动化特征
        page = browser.new_page()
        page.add_init_script('''
            Object.defineProperty(navigator, 'webdriver', {get: () => undefined});
            window.chrome = {runtime: {}};
        ''')
        return page

# 2. 智能等待策略 - 等待特定网络请求完成
def wait_for_content_load(page, timeout=10000):
    """等待页面核心内容加载完成"""
    try:
        # 等待主要内容的DOM元素出现
        page.wait_for_selector('main, article, .content', timeout=timeout)
        
        # 等待所有图片加载完成（排除懒加载）
        page.evaluate('''() => {
            return Promise.all(
                Array.from(document.images)
                    .filter(img => img.complete === false)
                    .map(img => new Promise(resolve => img.onload = resolve))
            );
        }''')
        return True
    except Exception as e:
        print(f'等待内容加载超时: {e}')
        return False

# 3. 请求限流和代理配置
import time
import random
from dataclasses import dataclass

@dataclass
class CrawlConfig:
    min_delay: float = 2.0  # 最小等待时间(秒)
    max_delay: float = 5.0  # 最大等待时间(秒)
    max_retries: int = 3
    proxy: str = None  # 代理服务器地址
    
    def random_delay(self):
        """随机延迟，模拟人类行为"""
        time.sleep(random.uniform(self.min_delay, self.max_delay))

• 避免频繁爬取触发反爬虫：使用代理池、随机延迟、stealth插件
• 正确配置等待策略：结合选择器等待和网络请求监控
• 引入机器学习提升准确性：训练内容理解预测模型、使用CV验证视觉一致性
• 性能优化：使用context复用实现并发、分布式任务队列、结果缓存
• 容器化部署：使用Docker封装测试环境，便于协作和扩展

通过本教程，你已经掌握了使用Playwright构建完整AI爬虫模拟测试系统的全部关键技术。从环境搭建到脚本编写，从数据分析到报告生成，从单页测试到批量自动化，这套系统能够帮助你深入理解网站在AI搜索引擎眼中的表现，并指导有效的GEO优化工作。记住，GEO是一个持续优化的过程，而不是一次性的项目。建议将本教程中的测试系统定期运行，建立GEO性能的基线并持续追踪改进效果。祝你的网站在AI搜索时代取得优异的表现！