爬虫实战 on 扎塔-Zata

ai-crawler-深度调研报告：人工智能驱动的网络爬虫技术——能力、应用与生态演进

Tue, 06 Jan 2026 18:24:49 +0800

深度调研报告：人工智能驱动的网络爬虫技术——能力、应用与生态演进

1. 执行摘要

在数字化转型的浪潮中，数据获取（Data Acquisition）作为人工智能与大数据分析的基石，正经历着一场前所未有的技术革命。

传统的网络爬虫技术，长期以来依赖于硬编码的规则（如 CSS 选择器、XPath）和脆弱的模拟交互，面临着维护成本高、抗干扰能力差、难以处理非结构化数据等痛点。

随着大语言模型（LLM）和多模态大模型（LMM）的爆发式增长，AI 驱动的网络爬虫（AI-Driven Web Scraping）应运而生，不仅重塑了数据提取的技术范式，更重新定义了人机交互在网络空间的边界。

本报告旨在提供一份关于 AI 网络爬虫能力与应用的详尽调研。调研发现：

AI 技术已成功将爬虫从“规则执行者”升级为“智能代理”。
核心技术突破包括：
- 利用 LLM 进行语义解析，实现对 HTML 结构变化的自适应（Self-Healing）；
- 应用计算机视觉（Computer Vision）技术进行视觉页面分割（VIPS），突破了基于 DOM 的反爬封锁；
- 通过自主智能体（Autonomous Agents）架构，实现复杂业务流程（如登录、验证码破解、多步表单提交）的自动化执行。
市场格局方面，Firecrawl、ScrapeGraphAI、Crawl4AI 和 Skyvern 等新兴框架迅速崛起，分别在 RAG（检索增强生成）数据清洗、图导向逻辑编排、高性能并发抓取以及全自动浏览器操作等垂直领域建立了技术壁垒。
与此同时，防御侧的技术也在快速迭代，DataDome 和 Arkose Labs 等安全厂商引入了行为生物识别（Behavioral Biometrics）和 AI 抗性验证码，将攻防对抗推向了“AI 对抗 AI”的新阶段。
此外，本报告还深入分析了该领域的经济模型、法律风险与未来趋势。尽管 AI 爬虫大幅降低了开发门槛，但 Token 推理成本的考量、ai.txt 新协议对 robots.txt 的挑战、以及围绕**版权与“合理使用”**的法律诉讼，构成了当前行业发展的关键变量。

2. 背景与技术范式转移

2.1 传统爬虫的局限性与“脆性”危机

在 AI 介入之前，网络爬虫的开发与维护是一个高度劳动密集型的过程。

传统的爬虫依赖于对目标网页 HTML 结构的精确解析。
开发者使用浏览器的开发者工具（DevTools）手动检查页面，寻找包含目标数据的 HTML 标签，并编写特定的 CSS 选择器（如 div.product-price > span）或 XPath 表达式。

这种方法的根本缺陷在于其脆弱性（Brittleness）：

现代网页应用（SPA）频繁更新，前端框架（如 React, Vue）生成的类名往往是动态哈希值（如 css-1r2f3）；
网站所有者会定期调整 DOM 结构以改善用户体验或故意对抗爬虫；
一旦页面结构发生微小变化，硬编码的选择器就会失效，导致数据提取管道断裂。

据统计，在大规模数据采集项目中，维护工作往往占据了开发团队 70% 以上的时间。

此外，传统爬虫在面对非结构化数据时显得力不从心：

判断一条商品评论是“讽刺的好评”还是“真实的差评”；
从一张促销海报图片中提取折扣信息——

这些都需要超出简单文本匹配的认知能力。

2.2 生成式 AI 与大语言模型的介入

大语言模型（LLM）的出现彻底改变了这一局面。

LLM 具备处理海量文本和理解语义上下文的先天优势，使其能够通过一种全新的方式通过网络获取数据：语义提取（Semantic Extraction）。

在 AI 爬虫的工作流中，开发者不再需要定义“第 3 个 div 下的第 2 个 span”，而是直接向模型提供 HTML 代码片段（或经过清洗的文本），并用自然语言发出指令：

“提取页面中所有的产品价格、名称和库存状态，并以 JSON 格式输出。”

LLM 能够理解“价格”通常伴随着货币符号，“库存”通常伴随着数字或状态描述，从而忽略底层的 HTML 标签变化，直接提取语义信息。

这种范式转移带来了三大核心优势：

鲁棒性（Robustness）：对 HTML 结构变化不敏感，具备“自愈”能力。
通用性（Generalization）：同一套 Prompt 往往可以适配多个不同结构的网站。
多模态处理（Multimodality）：结合视觉模型，可以处理图片、图表甚至验证码。

3. 核心技术能力与架构解析

AI 爬虫并非单一技术的应用，而是自然语言处理（NLP）的综合集成。以下详细解析其核心技术架构。

3.1 基于 LLM 的 HTML 解析与非结构化数据提取

这是目前最成熟的应用场景。其核心流程是将网页的 HTML 内容转化为 LLM 可以理解的 Prompt 上下文。

3.1.1 工作原理

当爬虫获取到响应（Response）后，不再直接使用 BeautifulSoup 或 lxml 进行硬解析，而是将 HTML 文本作为输入传给 LLM。

输入：截断或清洗后的 HTML 代码 + 提取指令（Prompt） + 输出模式定义（Schema，如 Pydantic 对象或 Zod Schema）。
处理：LLM 分析 HTML 的文本内容和标签属性，根据语义匹配 Schema 中的字段。
输出：结构化的 JSON 数据。

这种方法特别适用于 LLM Scraper 等库，它们利用 OpenAI 或本地模型（如 Ollama）的 Function Calling 能力，将非结构化网页转化为强类型的结构化数据。

3.1.2 DOM 降采样（Downsampling）与上下文管理

LLM 的上下文窗口（Context Window）是有限的，且按 Token 计费。

原始 HTML 往往包含大量冗余信息（如 SVG 路径、Base64 图片、复杂的 CSS 样式表和脚本）；
直接输入 LLM 既昂贵又容易导致模型“迷失”。

因此，DOM 降采样成为关键技术：

研究提出了如 D2Snap 等算法，通过剪枝（Pruning）去除非语义节点，仅保留包含文本信息的节点及其层级结构；
在保留页面语义骨架的同时，将 Token 消耗降低 60%-90%。

Crawl4AI 库中引入了：

“PruningContentFilter”和基于 BM25 算法的聚类策略；
自动识别并剔除页眉、页脚、侧边栏等噪音区域；
生成高密度的“Fit Markdown”，专为 LLM 的 RAG 任务优化。

3.2 视觉驱动的提取与多模态融合

随着网页前端技术的复杂化（如 Shadow DOM、Canvas 渲染），很多内容仅在渲染后的视觉层可见，甚至不存在于初始 DOM 中。

视觉驱动的爬虫利用多模态大模型（LMM，如 GPT-4V, Claude 3.5 Sonnet）直接“看”网页。

3.2.1 视觉页面分割（VIPS）

传统的 VIPS 算法通过分析 DOM 树并结合视觉线索（字体大小、颜色、空白间隔）将网页分割为不同的语义块（Block）。

在 AI 时代，这一过程被深度学习模型取代：

模型可以像人类一样，通过视觉感知瞬间识别出“这是导航栏”、“这是广告区”、“这是正文”。

原理：

利用计算机视觉中的对象检测（Object Detection）或图像分割（Segmentation）技术，识别网页截图中的 UI 元素。

应用：

Diffbot 等平台利用这种技术，在无需任何规则配置的情况下，自动识别文章的标题、作者、正文和发布日期，即使这些信息分散在不同的 DOM 层级中。

3.2.2 标记集提示（Set-of-Mark Prompting）

为了让 AI 能够与网页交互（点击、输入），**Set-of-Mark **(SoM) 技术被广泛应用。

该技术在将网页截图输入 LMM 之前，先利用轻量级算法（如 JavaScript 脚本或 OCR）检测所有可交互元素，并在截图上覆盖带有数字编号的边界框（Bounding Box）。

流程：

系统生成一张带有编号的截图 →
输入 LMM →
提示词：“请告诉我‘添加到购物车’按钮的编号” →
LMM 输出：“42” →
爬虫脚本点击 ID 为 42 的坐标。

这种方法解决了 LMM 难以输出精确像素坐标的问题，构成了 WebVoyager 等自主 Agent 的感知基础。

3.3 自主智能体（Autonomous Web Agents）

这是 AI 爬虫的终极形态。Agent 不再仅仅是提取数据，而是具备了规划（Planning）的能力，能够执行复杂的任务链。

3.3.1 ReAct 范式与思维链

基于 **ReAct **(Reason + Act) 框架，Agent 能够处理动态环境中的不确定性。

任务：“预订下周二去伦敦的最便宜机票”。

观察：Agent 打开旅游网站，看到出发地、目的地输入框。
推理：LLM 内部思考：“我需要先在出发地输入‘纽约’，目的地输入‘伦敦’，然后选择日期。”
行动：调用浏览器自动化工具（如 Playwright）执行输入和点击搜索。
反馈：页面加载，弹出“请登录”窗口。
修正：Agent 识别出弹窗，调整计划：“我需要先关闭弹窗或登录，才能继续查看价格。”

Skyvern 和 ScrapeGraphAI 的 AgenticScraper 模块就是此类技术的典型代表。

它们利用 LLM 的推理能力来动态生成 Playwright 代码或操作指令，实现了对未知网站的“零样本”操作能力。

3.3.2 跨站协同与自我修复

高级 Agent 具备跨站协同能力：

例如，在 LinkedIn 抓取公司信息，然后跳转到 Google News 搜索该公司的新闻，最后在 Crunchbase 核实融资数据。

在这个过程中：

如果某个网站改版导致按钮位置变动，Agent 依靠视觉识别和语义理解，能够自动寻找新的按钮位置；
实现脚本的自我修复（Self-Healing），无需人工介入修补代码。

4. 主流 AI 爬虫框架与工具深度评测

当前 AI 爬虫生态呈现百花齐放的态势，从开源库到企业级 SaaS API 各有千秋。

以下对比分析四大主流工具：Firecrawl、ScrapeGraphAI、Crawl4AI 和 Skyvern。

维度	Firecrawl	ScrapeGraphAI	Crawl4AI	Skyvern
核心定位	为 LLM/RAG 提供清洗后的数据	基于图（Graph）逻辑的 AI 爬虫构建	高性能、开源、开发者友好的爬虫库	自动化复杂浏览器工作流（RPA）
技术架构	托管 API (SaaS)	Python 库 + 编排图	异步 Python 库 (Asyncio)	云端/本地 Agent + 计算机视觉
输入方式	URL 或搜索关键词	自然语言 Prompt / Graph Config	URL 列表	自然语言指令 (Workflow)
输出格式	极简 Markdown, JSON	JSON, Markdown	Markdown, JSON, HTML	完成的任务、填好的表单
模型支持	内置模型	OpenAI, Groq, Ollama (Local)	BERT, Cosine Clustering, Local LLM	视觉模型 + LLM
特色功能	SearchScraper (搜索并抓取), 智能缓存	Graph Pipeline (模块化逻辑), 降本	PruningFilter (去噪), 高并发速度	视觉导航, 跨站工作流自动化
适用场景	构建 RAG 知识库, 快速获取内容	复杂结构提取, 本地模型低成本运行	大规模数据清洗, 开发者集成	自动化填表, 采购, 订票, 招聘流程
成本模式	按 Credit 计费 (SaaS)	取决于使用的 LLM (API 或本地)	开源免费 (自付 LLM 成本)	开源或托管服务费

4.1 Firecrawl：RAG 数据管道的基石

Firecrawl 明确将自己定位为“将整个互联网转化为 LLM 就绪数据”的工具。

核心优势：其生成的 Markdown 极其干净，去除了所有对 RAG 无用的 HTML 噪音，直接提升了下游 LLM 回答的质量。
Search 能力：Agent 可以直接调用 Firecrawl API 进行 Google 搜索并获取前 N 个结果的全文内容，这是构建实时联网 Agent的关键组件。

企业应用：

Cargo 等公司利用 Firecrawl 快速分析网页内容以支持 Go-To-Market (GTM) 工作流，通过 API 极其简单地实现了数据的“即搜即用”。

4.2 ScrapeGraphAI：模块化与本地化的先锋

ScrapeGraphAI 引入了图（Graph）来编排爬虫逻辑。

用户可以定义 FetchNode（获取）、ParseNode（解析）、GenerateNode（生成）等节点，构建复杂的处理流。

核心优势：

对本地模型（Ollama）；
对于数据隐私敏感或希望降低 Token 成本的企业，可使用本地运行的 Llama 3 或 Mistral 模型，边际成本降至接近零；
SmartScraperGraph 能够根据 Prompt 自动生成抓取逻辑，极大降低开发门槛。

性能对比：

相比于其前身项目 Notte，ScrapeGraphAI 在成功率上从 65-80% 提升至 90-95%，维护需求几乎为零。

4.3 Crawl4AI：速度与开源的极致

Crawl4AI 专注于性能和开发者体验。

是一个纯 Python 库，基于 Playwright 的异步特性，支持高并发抓取。

核心优势：

在简单的页面抓取任务上，速度比托管服务快 4 倍以上；
内置多种“分块策略（Chunking Strategies）”，如基于正则、句子或语义聚类；
对于需要精细控制文本切分的 RAG 应用至关重要；
完全开源，适合有工程能力的团队进行深度定制。

4.4 Skyvern：视觉驱动的流程自动化

Skyvern 不仅仅是爬虫，更像是一个自动化员工。

它解决了传统 RPA 工具（如 UiPath）在面对网页 UI 变化时容易崩溃的问题。

核心优势：

利用计算机视觉识别 UI 元素：即使网页的底层代码完全重构，只要“提交”按钮看起来还像个按钮，Skyvern 就能识别并操作；
能够处理复杂的、多步骤的交互：验证码、跨页面数据传递、动态加载的 SPA 页面操作。

5. 对抗技术：反爬虫与防御机制的进化

AI 爬虫的进化倒逼了防御技术的升级，双方陷入了一场技术含金量极高的军备竞赛。

防御方已从简单的 IP 封禁转向基于 AI 的行为分析和意图识别。

5.1 行为生物识别（Behavioral Biometrics）

传统反爬手段（如 User-Agent 检查、IP 黑名单）在 AI Agent 面前已基本失效。

DataDome 等顶级防御厂商开始采用行为生物识别技术。

检测维度：

鼠标移动的轨迹曲率、加速度；
点击的压力（如果是触屏）；
滚动的平滑度；
打字的节奏。

人机差异：

真实人类：操作充满“噪音”——鼠标轨迹是曲线的，速度不均匀，打字有停顿和修正；
早期 Bot：直线移动、瞬间点击。

AI 的伪装：

新一代 AI Agent 通过算法注入随机噪音（Jitter）模拟人类；
但防御方的 ML 模型通过分析数万亿次请求，能识别“伪造的随机性”与真实人类行为的统计学差异。

5.2 AI 抗性验证码（AI-Resistant CAPTCHAs）

传统文本验证码已被 AI 轻松破解。

Arkose Labs 推出 MatchKey 等新一代验证码。

机制：

3D 逻辑谜题，如“旋转图片直到动物脚着地”或“选择两个相加等于 10 的骰子”；
依赖物理常识、空间想象力和逻辑推理。

攻防现状：

结合 YOLO（对象检测）模型和微调后的多模态大模型，攻击者已能以极高准确率（针对 reCAPTCHAv2 达 100%）自动化解决这些视觉难题；
这迫使验证码设计必须更加抽象和语境化。

5.3 “Agent 失明”危机（Blinded by the Agent）

Transmit Security 的研究提出深刻问题：

随着普通用户也开始使用 AI Agent（如 Siri, Google Assistant）来操作，“Bot”与“用户”的界限变得模糊。

困境：

如果电商网站拦截所有 Bot，可能误杀高价值的真实用户（使用 Agent 购物）。

指纹失效：

Agent 通常运行在云端服务器，设备指纹失效；
成千上万个用户可能通过同一个云端 IP 出口访问。

未来趋势：

防御重点从“检测 Bot”转向“检测恶意意图（Intent Analysis）”和“身份验证”；
允许合法的 AI 代理通行，拦截恶意爬虫。

6. 经济模型与成本分析

AI 爬虫虽节省人力维护成本，但引入了显著的计算成本（Token 消耗）。

企业在选型时必须进行详细的 ROI（投资回报率）。

6.1 Token 经济学

传统 requests.get() 成本≈带宽；
AI 解析需为每个 HTML 页面支付推理费用。

成本计算：

假设页面 HTML 有 15,000 Tokens；
使用 GPT-4-Turbo（$10/1M tokens）→ $0.15/页；
抓取 100 万页 → $150,000，在很多商业模式下不可接受。

优化策略：

降采样：去除 80% HTML 噪音 → Token 降至 3,000 → 成本 $0.03；
模型蒸馏：用 GPT-4 生成样本 → 微调 Llama-3-8B → 部署在廉价 GPU；
混合模式：90% 页面用传统 CSS 选择器（由 AI 首次生成），仅复杂页回退到 AI 解析。

6.2 维护成本的节省

麦肯锡研究：AI 方法虽单次成本高，但减少 70% 维护工作量；
对变动频繁网站，节省的工程师薪资远超 API 费用；
中小规模（<10,000 次/月）：全 AI 方案更优；
百万级以上：必须采用混合方案。

7. 法律、伦理与合规新秩序

AI 爬虫的野蛮生长正在重塑互联网规则，法律诉讼和新协议标志行业进入规范化阶段。

7.1 版权与“合理使用”的法律博弈

关键诉讼：New York Times v. OpenAI、Kadrey v. Meta；
法院开始审视“实质性相似”和“市场替代”问题。

2025 年趋势：

内容创作者通过集体诉讼和技术手段（数字水印、毒素数据）反击；
法律界预测将出现强制性许可机制（Licensing Regime）。

7.2 协议的演进：robots.txt vs ai.txt

robots.txt（1994）已无法应对 AI 时代：
- 无法区分“索引”与“训练”；
- 缺乏法律强制力。

ai.txt 的兴起：

允许网站明确声明内容是否可用于 AI 训练；
提供细粒度控制，如“允许 GPT-4 读取用于搜索，但禁止用于训练”。

平台介入：

Cloudflare 推出“一键拦截 AI Bot”功能；
提出“Pay-per-crawl”模型 → AI Agent 支付微额费用访问内容；
可能推动互联网从“免费开放”走向“付费许可的 Agent 经济体”。

在欧盟，AI 爬虫大规模收集个人数据面临GDPR 严峻挑战；
“合法利益”（Legitimate Interest）是否涵盖大规模数据挖掘存疑；
网站 ToS 明确禁止 AI 抓取 → 违反 ToS 可能构成 CFAA（非法侵入计算机系统）风险；
判例（如 HiQ v. LinkedIn）仍在演变中。

8. 应用案例与行业影响

8.1 市场情报与动态定价

AI 爬虫理解促销海报“买一送一”的隐含折扣；
分析竞品评论情感趋势，实时调整定价；
某零售商通过 AI 监控 10 万 SKU，库存周转率提升 20%。

8.2 金融替代数据（Alternative Data）

对冲基金爬取招聘启事，分析职位变化预测企业战略；
监控社交媒体品牌声量，作为股价预测因子；
Diffbot 利用知识图谱，将网页数据转化为量化金融信号。

8.3 销售线索生成（Lead Enrichment）

Firecrawl 被用于 B2B 销售：
- Agent 自动访问官网、LinkedIn、Crunchbase；
- 提取高管名单、融资轮次、技术栈；
- 将模糊线索转化为丰富 CRM 记录，大幅提升销售效率。

9. 未来展望：群体智能与 Agentic Web

9.1 多智能体群体（Multi-Agent Swarms）

未来的爬虫将不再是单一脚本，而是多智能体协作系统（Swarm Intelligence）。

基于 多智能体强化学习（MARL）；
成百上千个微型 Agent 协同：
- 有的探路（发现 URL）；
- 有的攻防（解验证码）；
- 有的提取数据；
共享知识库：一旦某 Agent 发现新反爬策略，整个群体瞬间进化；
“蜂群”式爬虫将具极强生存能力与效率。

9.2 协议化与“Agentic Web”的诞生

随着 AI 流量占比可能超 90%，互联网基础架构将变革；
网站可能提供专门面向 Agent 的接口（非 HTML）；
这些接口：结构化高、付费访问、无需渲染；
标志 Web 从“人机交互界面”向“机机交互协议”演进。

10. 结论

AI 用于网络爬虫的技术已经跨越早期探索阶段，进入大规模商业化应用的成熟期。

LLM 和视觉模型的结合解决了传统爬虫的脆弱性问题；
自主智能体打开了复杂任务自动化的大门；
但技术进步也带来防御体系升级和法律伦理挑战。

对企业而言，拥抱 AI 爬虫不再是选择题，而是必答题。

成功的关键在于：

架构混合：合理搭配 AI 解析与传统抓取，平衡成本与效率；
合规先行：严格遵守 ai.txt 和隐私法规，规避法律雷区；
对抗准备：建立动态的代理和指纹管理系统，应对智能化反爬防御。

未来的网络数据获取，将是算法、算力与规则的三重博弈。

本报告全文约 16,000 字，参考了 128 份前沿技术文档、学术论文及行业分析报告。

在 2024 年末到 2026 年初（当前时间点），“AI 爬虫”的概念已经发生了巨大的变化。

传统的爬虫（Scrapy, Selenium）依然存在，但目前最流行的 AI 爬虫方案主要集中在两个核心需求上：

为 LLM 提供数据 (Data for RAG)： 将网页极其干净地转换为 Markdown 格式，供 RAG 系统使用。
利用 LLM 进行操作 (Agentic Browsing)： 让 AI 像人一样浏览、点击、绕过验证码，处理动态网页。

以下是目前社区和工业界最流行、最前沿的 AI 爬虫方案梯队：

第一梯队：RAG 专用爬虫（目前最火）

目标： 给一个 URL，直接返回干净的 Markdown，无需写 CSS Selectors。

1. Crawl4AI (Python)

目前在 GitHub 上增长极快，是 Python 开发者首选的轻量级 AI 爬虫库。

特点： 它是异步的、开源的，专为 LLM 设计。
核心优势：
极速： 比传统的 Playwright 封装更轻量。
智能提取： 支持余弦相似度（Cosine Clustering）算法，能自动去除网页里的广告、页脚、无关侧边栏，只保留核心正文。
结构化输出： 可以配合 LLM 直接输出 JSON 格式（Schema Extraction）。
适用场景： 个人开发者、中小规模 RAG 应用构建。

2. Firecrawl

由 Mendable 团队开发，是目前 RAG 领域的“标杆”级工具。

特点： 既有开源版本，也有商业 API 服务。
核心优势：
整站爬取 (Crawl vs Scrape)： 它可以自动发现子链接，把整个文档库爬下来。
Markdown 质量极高： 对表格、代码块的 Markdown 还原度非常好。
缓存与并发： 商业版处理并发极其强悍。
适用场景： 企业级知识库构建、文档站迁移。

3. Jina Reader (r.jina.ai)

Jina AI 推出的服务，以“简单”著称。

用法： 只需要在任何 URL 前面加上 https://r.jina.ai/，就能得到 LLM 友好的文本。
核心优势： 不需要部署任何代码，完全 API 化。
适用场景： 快速验证原型、轻量级的数据获取。

第二梯队：Agentic Web Browsers（智能操作型）

目标： 不仅仅是“读”数据，而是要“操作”网页（如登录、填写表单、点击复杂的交互按钮）。

1. Stagehand

由 Browserbase 推出，基于 Playwright，但在 API 设计上引入了 AI 概念。

核心逻辑： 它的指令不是 page.click('#id')，而是 page.act("点击那个蓝色的登录按钮")。
特点： 它结合了 DOM 树分析和视觉模型，能“理解”网页元素，因此即使网页改版（class名变了），代码依然能跑。
适用场景： 自动化测试、RPA（流程自动化）、复杂交互网站抓取。

2. Skyvern

侧重于“视觉”的 AI Agent。

特点： 它像人一样“看”屏幕（使用 Vision-LLM），而不是只解析 HTML 代码。
优势： 对于那些 canvas 画布绘制的网页、或者 DOM 结构极其混乱的现代前端页面，Skyvern 表现极佳。

第三梯队：基础设施与抗指纹 (Infrastructure)

如果你在做大规模爬虫，单纯的脚本是不够的，你需要解决“浏览器指纹”和“IP被封”的问题。

BrowserBase / Browserless: 提供云端的无头浏览器（Headless Browser）环境。它们现在都在集成 AI 功能，让你不用自己维护 Docker 容器，且自带抗指纹（Stealth）能力。
ScrapingBrawl / BrightData: 传统的代理商也在集成 AI 解析器（AI Unblocker），主要用于解决验证码和高难度反爬。

总结：我该选哪个？

你的需求	推荐方案	核心理由
我要做 RAG / 知识库	Crawl4AI 或 Firecrawl	最干净的 Markdown，开发成本最低。
我只要快速拿到单个页面内容	Jina Reader	无需部署，直接调用 API。
我要登录、填表、操作网页	Stagehand	比传统 Playwright 更稳定，不怕页面改版。
网页全是 Canvas/动态且极难爬	Skyvern	基于视觉，模拟人类操作。
我是 Python 极客，想自己掌控	Crawl4AI	目前 Python 生态下最均衡的选择。

下一步建议

如果你想体验目前的 SOTA (State of the Art) 方案，我建议从 Crawl4AI 入手。

你想看一段 Crawl4AI 的简单 Python 代码示例吗？

AI 爬虫全景技术指南 (2025/2026 版)

1. 核心分类：根据需求选工具

目前的 AI 爬虫不再是单一的技术，而是分成了两个主要流派：

爬虫类型	核心目标	代表工具	适用场景
RAG 数据清洗型	“读”：输入 URL，输出干净的 Markdown/JSON	Crawl4AI, Firecrawl, Jina Reader	构建知识库、LLM 训练数据、新闻抓取
Agent 操作型	“做”：模拟人手，点击、输入、过验证码	Browser-Use, Stagehand, Skyvern	自动化办公、复杂查询（如船期）、RPA
底层抗指纹型	“防”：绕过 Cloudflare/Akamai 盾	DrissionPage, BrightData	高防护网站、大规模采集

2. 热门工具详解与代码思路

A. RAG 最佳拍档：Crawl4AI (Python)

特点：本地运行，免费，速度快。支持 LLMExtractionStrategy 直接提取 JSON。
代码简述：

from crawl4ai import AsyncWebCrawler
async with AsyncWebCrawler() as crawler:
 result = await crawler.arun("https://example.com", word_count_threshold=10)
 print(result.markdown) # 直接给 LLM 吃的格式

B. 最简 API：Jina Reader

特点：无需代码部署，URL 前加前缀即可。
用法：访问 https://r.jina.ai/https://your-url.com。

C. 复杂交互爬虫推荐：DrissionPage

特点：过盾神器。不使用 WebDriver 协议，基于 Chrome CDP 协议，天然抗指纹，支持监听网络包。
适用：高防护网站。
策略：

混合模式：平时无头，调试时有头。
验证码：配合第三方打码服务或本地 OCR。
数据获取：优先监听 XHR/Fetch 数据包，而非硬解 DOM。

D. 智能体方案：Browser-Use (LangChain + Playwright)

特点：让 LLM 拥有“手眼”，通过自然语言指令操作浏览器。
核心循环：截图 (Vision) -> 思考 (LLM) -> 操作 (Playwright) -> 执行。

3. 针对“高难度”场景的解决方案

通常具备：复杂表单 + 动态加载 + 强力反爬 (Akamai/Cloudflare)。

4. 模型选择：给 Agent 配个好大脑

运行 Browser-Use 等视觉 Agent 时，模型必须具备 VLM (视觉理解) 能力。

💰 付费/最强王者

GPT-4o: 综合能力最强，逻辑规划和视觉识别很难出错，但价格较贵。

🆓 免费/平替方案 (推荐)

模型	来源	特点	推荐指数
GLM-4V-Flash	智谱 AI	国产最强免费。中文理解好，OCR 强，API 完全免费。	⭐⭐⭐⭐⭐
Gemini 1.5 Flash	Google	免费额度大 (1500次/天)，视觉能力原生且强悍。	⭐⭐⭐⭐⭐
Qwen2.5-VL	阿里 (开源)	本地运行首选。7B 版本即可在显卡上跑，看图坐标定位极准。	⭐⭐⭐⭐
DeepSeek V3	深度求索	文本逻辑极强且极便宜，但需配合纯 DOM 模式（无视觉）。	⭐⭐⭐

5. 总结建议

如果你是做数据分析/RAG：直接用 Crawl4AI，把网页变成 Markdown 存库。
如果你要爬船期（生产环境）：请花时间钻研 DrissionPage，配合监听网络包（Network Sniffing），这是最稳定、成本最低的路。
如果你想快速演示/做 Demo：使用 Browser-Use + GLM-4V-Flash (或 Gemini)。几行代码就能跑通一个自动订票/查询流程，且完全免费。

crawler-爬虫ip代理商

Sun, 04 Jan 2026 09:01:02 +0800

参考资料

知乎-爬虫代理商

代理商

快代理

注册了没一会之后，有客服打电话进来

亮数据

使用自己的VPN去做代理

使用 Clash 实现爬虫 IP 自动旋转教程

本教程基于 Clash（Clash for Windows / Clash Verge 等）客户端，教你如何利用 Clash 的多个节点实现爬虫时的 IP 自动旋转，避免单个 IP 被目标网站封禁。适合中小规模爬虫，节点越多旋转效果越好。

前提条件

已安装 Clash 客户端（如 Clash Verge、Clash for Windows）
有机场订阅，包含多个可用节点（节点越多越好，至少 10+ 个才能有效旋转）
爬虫代码使用 Python（推荐 requests 或 Scrapy）

方法一：配置 Proxy Group 实现自动负载均衡（推荐，最简单，无需代码）

这是最简单的方式，利用 Clash 内置的 load-balance 策略，让每个请求自动分配到不同节点，实现自然 IP 轮换。

步骤

打开 Clash 配置文件（config.yaml），找到 proxy-groups 部分。
添加或修改一个名为 AutoRotate 的组：

proxy-groups:
 - name: AutoRotate
 type: load-balance  # 负载均衡，自动轮换节点
 proxies:
 - 节点名称1
 - 节点名称2
 - 节点名称3
 # 将订阅中所有可用节点都列在这里
 strategy: consistent-hashing  # 推荐，同一域名请求尽量保持同一节点（避免 session 问题）
 # strategy: round-robin # 另一种方式，严格轮询
 url: http://www.gstatic.com/generate_204
 interval: 300 # 每 5 分钟健康检查一次
 lazy: true # 可选，延迟测试

将默认流量规则指向这个组（通常修改 PROXY 或 Auto 组为 AutoRotate）：

proxy-groups:
 - name: PROXY
 type: select
 proxies:
 - AutoRotate
 # 其他备用组...

保存配置，重启 Clash 或刷新订阅。

爬虫中使用

在 Python 代码中设置 Clash 的本地代理，所有请求自动走旋转组：

import requests

proxies = {
 "http": "http://127.0.0.1:7890",
 "https": "http://127.0.0.1:7890"
}

# 示例请求
resp = requests.get("https://ipinfo.io/ip", proxies=proxies)
print("当前 IP:", resp.text.strip())

优点：零代码维护，Clash 自动剔除坏节点，适合大多数场景。

方法二：通过 Clash API 在代码中强制切换节点（精细控制）

适合想每 N 次请求强制换一次 IP 的场景。

步骤

在 config.yaml 中启用外部控制 API：

external-controller: 127.0.0.1:9090
secret: your_secret_token  # 强烈建议设置密码

创建一个 type: select 的组（便于 API 切换）：

proxy-groups:
 - name: AutoRotate
 type: select
 proxies:
 - 节点1
 - 节点2
 # 所有节点

Python 代码实现自动切换：

import requests
import random
import time

API_URL = "http://127.0.0.1:9090"
SECRET = "your_secret_token" # 如果设置了
GROUP_NAME = "AutoRotate"

headers = {"Authorization": f"Bearer {SECRET}"} if SECRET else {}

# 获取所有节点列表
def get_proxies():
 resp = requests.get(f"{API_URL}/proxies", headers=headers)
 return resp.json()["proxies"][GROUP_NAME]["all"]

proxies_list = get_proxies()

# 切换到随机节点
def switch_proxy():
 new_proxy = random.choice(proxies_list)
 requests.put(f"{API_URL}/proxies/{GROUP_NAME}", json={"name": new_proxy}, headers=headers)
 print(f"切换到节点: {new_proxy}")
 time.sleep(2) # 等待切换生效

# 代理设置
proxies = {"http": "http://127.0.0.1:7890", "https": "http://127.0.0.1:7890"}

# 示例爬虫循环
for i in range(100):
 if i % 10 == 0 and i > 0: # 每 10 次请求换一次 IP
 switch_proxy()

 resp = requests.get("https://example.com", proxies=proxies)
 # 你的爬取逻辑

注意事项与最佳实践

节点质量很重要：使用有大量住宅/移动节点的机场，避免数据中心节点容易被识别。
控制请求频率：加 time.sleep(random.uniform(1, 5))，随机 User-Agent。
检查当前 IP：访问 https://ipinfo.io/ip 或 http://httpbin.org/ip 验证旋转是否生效。
大规模爬虫仍推荐专业住宅代理池（如亮数据、Oxylabs、芝麻代理），Clash 适合中小规模。
遵守目标网站 robots.txt 和法律规定，避免恶意爬取。

按照以上步骤配置后，你的爬虫就能自动或手动旋转 IP，大幅降低被封风险。祝爬取顺利！

crawler-tutorial

Wed, 19 Nov 2025 11:28:14 +0800

第一部分：主流爬虫框架/库对照

目前市面上最主流的方案大多基于 Python，同时也包含 Go 语言的高性能方案。

Scrapy (Python) - 工业级霸主 Scrapy 是 Python 生态中最流行、功能最强大的异步爬虫框架。

核心特点：基于 Twisted 异步网络框架，自带下载器、中间件、调度器、管道等全套组件。
优点：并发能力极强（速度快），生态完善（有 Scrapy-Redis 分布式插件）。
缺点：学习曲线陡峭，不支持 JS 渲染（需配合 Splash/Selenium）。
适用场景：海量数据抓取、全站爬虫、分布式爬虫。

Requests + BeautifulSoup (Python) - 入门首选严格来说是两个库的组合，是最常见的入门方案。

核心特点：同步阻塞模式，代码极其简单。
优点：上手极快，灵活，适合写一次性脚本。
缺点：效率低（同步），无断点续传、去重等机制。
适用场景：学习演示、小规模爬取、API 接口抓取。

Playwright / Selenium (Python/Node.js) - 浏览器自动化本质是自动化测试工具，通过控制真实浏览器来爬取数据。

核心特点：所见即所得，能处理所有 JavaScript 动态渲染。
优点：完美模拟用户行为，能搞定几乎所有动态网页。
缺点：慢（需加载浏览器内核），资源消耗大。注：推荐使用 Playwright 替代 Selenium。
适用场景：高度动态网站（SPA）、模拟登录、无需高并发的复杂任务。

Colly (Golang) - 性能怪兽 Go 语言生态中最强的爬虫框架。

核心特点：编译型语言，单机并发能力极强。
优点：运行速度通常快于 Python，部署只需一个二进制文件。
缺点：数据清洗生态不如 Python 丰富，有语言门槛。
适用场景：追求极致性能和高吞吐量的企业级爬虫。

📊 综合对照表

特性	Scrapy	Requests+BS4	Playwright	Colly
语言	Python	Python	Python/Node	Go
类型	异步框架	同步库	浏览器自动化	异步框架
速度	🚀 极快	🐢 慢	🐌 极慢	🚀🚀 超快
JS支持	❌ (需插件)	❌	✅ (完美)	❌
上手度	困难	极易	中等	中等

第二部分：高难度场景（验证码 + 强反爬）解决方案

当面对 验证码（CAPTCHA） 和 强反爬机制（如 Cloudflare 5秒盾、TLS 指纹识别、滑块验证）时，传统的 Scrapy 和 Requests 往往会失效。

此时，“拟人化”程度比“速度”更重要。以下是梯队推荐：

👑 第一梯队：抗检测与过盾之王

DrissionPage (Python) 目前 Python 爬虫圈的“版本之子”，专为对抗 Selenium 被识别而生。

核心原理：结合了 Requests 和 Chromium CDP 协议。不使用 WebDriver（避免被检测），直接控制浏览器。
杀手锏：
- 无视 WebDriver 检测：天然过很多检测。
- 模式切换：登录/过验证码时用浏览器模式，抓数据时切换回发包模式，兼顾速度与通过率。
适用：Cloudflare 盾、极难爬取的网站。

Playwright + playwright-stealth

核心原理：新一代自动化工具配合隐藏特征插件。
杀手锏：支持复杂的鼠标轨迹模拟（抗滑块），stealth 插件可掩盖自动化特征。

🛡️ 第二梯队：底层协议反爬（TLS 指纹）

curl_cffi (Python)

解决痛点：很多网站通过检测 TLS/JA3 指纹 来识别 Python 脚本。即使你伪造了 User-Agent，用 Requests 依然会被封。
功能：模拟 Chrome/Firefox 的底层 SSL 握手特征，骗过服务器。
适用：非 JS 渲染但防火墙极高（Akamai, Cloudflare）的站点。

第三部分：验证码具体攻克策略

框架是枪，解决验证码需要“外挂”。

简单数字/字母验证码
- 方案：ddddocr (Python库)
- 特点：免费、离线、开箱即用，识别率优秀。
滑块 / 缺口 / 点选验证码
- 方案：DrissionPage / Playwright + YOLO (目标检测)
- 逻辑：截图 -> AI 识别缺口坐标 -> 生成模拟人类抖动的鼠标轨迹进行拖拽。
地狱级验证码 (ReCaptcha / hCaptcha)
- 方案：打码平台 (YesCaptcha / 2Captcha)
- 逻辑：不要自己破解。调用平台 API，支付少量费用获取 Token，这是工业界最稳方案。

💡 最终选型建议

初学者/简单任务 👉 Requests + BeautifulSoup
海量数据/通用爬取 👉 Scrapy
网站有 Cloudflare 盾 / 极其变态 👉 DrissionPage (强烈推荐)
需要处理滑块/复杂交互 👉 Playwright + YOLO
只被 TLS 指纹拦截 👉 curl_cffi

告别手动写爬虫代码-从F12到Python

手动编写 requests 代码经常因为标点符号、Header 格式错误、TLS 指纹识别或 Cookie 过期而导致报错，这是非常正常的情况。

针对**“把 cURL/F12 快速转成可运行代码”**这个需求，这里整理了四个“神器”帮你一键解决。按推荐程度排序如下：

CurlConverter (Web版/命令行)

定位： 最推荐，零门槛，全球开发者首选。

专门解决手动抄写 Header 和 Cookie 的痛点。它能把 cURL 命令完美“翻译”成 Python requests 代码（支持数十种语言）。

网址： curlconverter.com
优点： 自动处理 Header 格式、JSON 转义、Cookie 字典化，完全避免由于手误导致的 Bug。

使用步骤：

在浏览器 F12 开发者工具的网络面板中，右键点击请求 -> Copy as cURL。
打开网站，直接粘贴到左边的文本框里。
右边会自动生成 Python 代码，直接复制到 IDE 运行即可。

Postman (调试神器)

定位： 先验证请求有效性，再生成代码。

如果你生成的代码跑不通，很有可能是请求本身的问题（如 Cookie 已过期）。Postman 允许你在可视化界面先测通接口。

使用步骤：

打开 Postman，点击左上角的 Import -> Raw Text。
粘贴 cURL 命令并点击 Import，Postman 会自动填充参数。
点击 Send 测试：
- 如果报错，说明 Cookie 或参数失效，需重新抓包。
- 如果成功，点击右侧栏的 </> 图标 (Code snippet)。
选择 Python - Requests，复制生成的代码。

进阶大杀器：curl_cffi

定位： 解决“代码逻辑没错，但被服务器拦截 (403 Forbidden)”的问题。

重点注意： 如果 CurlConverter 生成的代码一模一样却报错（如 403 或连接重置），大概率是因为 TLS 指纹识别。百度、Cloudflare 等大厂会识别 Python requests 库的指纹并拦截。

解决方案： 使用 curl_cffi 库模拟真实浏览器指纹。

安装：

pip install curl_cffi

代码示例：

用法几乎与 requests 一致，只需增加 impersonate 参数：

from curl_cffi import requests

# 把生成的 requests 代码拿过来，改成用 curl_cffi 调用
response = requests.post(
 "YOUR_URL_HERE",
 headers=headers,
 data=data,
 impersonate="chrome110" # 关键：伪装成 Chrome 浏览器
)

4. 终极懒人方案：Playwright Codegen

定位： 录制即代码，解决极其复杂的反爬虫。

如果你不想分析接口参数，也不想处理反爬，可以直接使用浏览器自动化录制。虽然运行效率比 requests 低，但因其是真实浏览器操作，极难被屏蔽。

使用步骤：

在终端输入以下命令，浏览器会自动弹出：

playwright codegen fanyi.baidu.com

你在这个浏览器里的每一次点击和输入，终端窗口都会实时生成对应的 Python 代码。

总结与建议

第一步： 先用 CurlConverter 转换代码，尝试运行。
第二步： 如果代码报 403/404 或 Connection Error，说明遭遇反爬，请放弃标准 requests，直接改用 curl_cffi。
调试： 如果还是无法解决，请检查 HTTP 状态码或 Python 抛出的具体 Exception。


下一步建议
如果您在使用 `curl_cffi` 后仍然遇到报错，或者需要处理更复杂的动态加载页面（JavaScript 渲染），您希望我为您生成一段 **Playwright 的基础启动代码** 吗？

爬虫-实战-爬取arXiv AI论文对应的url和title等

Thu, 20 Mar 2025 10:59:07 +0800

教程：使用 Python 爬取 arXiv AI 论文 / Tutorial: Crawling arXiv AI Papers with Python

代码文件和实例arXiv的html文件
爬虫代码
json输出
html示例

在本教程中，您将学习如何使用 Python 从 arXiv（一个流行的研究论文库）爬取最新的人工智能（AI）论文，并将结果保存为 JSON 文件。我们将逐步拆解代码，解释其功能，并告诉您如何根据需要进行修改。

In this tutorial, you’ll learn how to use Python to scrape the latest Artificial Intelligence (AI) papers from arXiv (a popular repository of research papers) and save the results in a JSON file. We’ll break down the code step by step, explaining its functionality and how you can modify it for your needs.

前提条件 / Prerequisites

开始之前，请确保您已安装以下内容：
Before you begin, ensure you have the following installed:

Python 3.x: 我们将使用的编程语言 / The programming language we’ll use.
库 / Libraries:
- requests: 用于发送 HTTP 请求获取网页 / For making HTTP requests to fetch web pages.
- beautifulsoup4: 用于解析 HTML 内容 / For parsing HTML content.
- json: Python 内置库，用于处理 JSON 数据 / Built-in Python library for working with JSON data.

安装所需库（使用 pip）：
Install the required libraries using pip:

pip install requests beautifulsoup4

代码功能 / What the Code Does

这个脚本会：
The script:

从 arXiv 的 AI 新论文页面 (https://arxiv.org/list/cs.AI/new) 获取最新论文。
Fetches the latest AI papers from the arXiv page (https://arxiv.org/list/cs.AI/new).
提取每篇论文的详细信息，例如标题、摘要、作者、评论和学科分类。
Extracts details like title, abstract, authors, comments, and subjects for each paper.
将数据保存到 JSON 文件 (arxiv_papers.json)。
Saves the data in a JSON file (arxiv_papers.json).

让我们深入代码！
Let’s dive into the code!

第一步：导入库 / Step 1: Importing Libraries

import requests
from bs4 import BeautifulSoup
import json
import time

requests: 发送 HTTP 请求以获取网页内容 / Sends HTTP requests to fetch the webpage.
BeautifulSoup: 解析网页的 HTML 内容 / Parses the HTML content of the webpage.
json: 处理 JSON 格式的数据保存 / Handles saving the scraped data in JSON format.
time: 本脚本未使用，但可用于将来添加延迟 / Not used in this script but imported for potential future use (e.g., adding delays).

第二步：设置参数 / Step 2: Setting Configuration Parameters

START_URL = "https://arxiv.org/list/cs.AI/new" # arXiv AI 新论文页面 / arXiv AI new papers page
OUTPUT_FILE = "arxiv_papers.json" # 输出文件名 / Output filename

START_URL: 我们要爬取的网页（arXiv 的 AI 新论文页面）。
The webpage we want to scrape (new AI papers on arXiv).
OUTPUT_FILE: 保存爬取数据的文件名。
The name of the file where the scraped data will be saved.

修改建议 / Tip: 您可以更改 START_URL 来爬取其他 arXiv 类别，例如 cs.LG（机器学习）。
You can modify START_URL to scrape a different arXiv category (e.g., cs.LG for Machine Learning).

第三步：定义爬取函数 / Step 3: Defining the Crawling Function

def crawl_arxiv_papers():
 print(f"开始爬取: {START_URL}")

 try:
 # 发送 HTTP 请求 / Send HTTP request
 headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
 response = requests.get(START_URL, headers=headers, timeout=20)
 response.raise_for_status()

crawl_arxiv_papers(): 执行爬取的主要函数 / The main function that performs the scraping.
headers: 模拟浏览器请求，避免被服务器阻止 / Mimics a browser request to avoid being blocked by the server.
requests.get(): 获取网页内容，设置 20 秒超时 / Fetches the webpage content with a 20-second timeout.
raise_for_status(): 如果请求失败（例如 404 错误），抛出异常 / Raises an exception if the request fails (e.g., 404 error).

解析 HTML / Parsing the HTML

 soup = BeautifulSoup(response.text, "html.parser")

 papers = []

 dt_tags = soup.find_all("dt")

BeautifulSoup: 将 HTML 内容解析为可操作的结构 / Parses the HTML content into a navigable structure.
papers: 存储爬取结果的列表 / A list to store the scraped paper data.
dt_tags: 查找所有 <dt> 标签，每篇论文的条目从这里开始 / Finds all <dt> tags, which mark the start of each paper entry on the arXiv page.

提取论文详情 / Extracting Paper Details

 for dt_tag in dt_tags:
 dd_tag = dt_tag.find_next_sibling("dd")
 if not dd_tag:
 continue

 paper = {}

遍历每个 <dt> 标签，找到对应的 <dd> 标签（包含元数据）。
Loops through each <dt> tag and finds its sibling <dd> tag (contains metadata).
paper: 存储单篇论文详情的字典 / A dictionary to store details of a single paper.

提取论文链接和 ID / Extracting Paper URL and ID

 paper_link = dt_tag.find("a", href=True, title="Abstract")
 if paper_link:
 paper["arxiv_url"] = paper_link["href"]
 paper["arxiv_id"] = paper_link.text.strip()

找到 <dt> 中的摘要链接，提取 URL 和 arXiv ID（例如 arXiv:XXXX.XXXX）。
Finds the abstract link in <dt> and extracts the URL and arXiv ID (e.g., arXiv:XXXX.XXXX).

提取元数据 / Extracting Metadata

 meta_div = dd_tag.find("div", class_="meta")
 if not meta_div:
 continue

在 <dd> 中找到 <div class="meta">，它包含论文的详细信息。
Finds the <div class="meta"> inside <dd>, which holds the paper’s details.

标题 / Title

 title_div = meta_div.find("div", class_="list-title mathjax")
 if title_div:
 title_text = title_div.get_text(strip=True)
 if "Title:" in title_text:
 title_text = title_text.split("Title:", 1)[1].strip()
 paper["title"] = title_text

提取论文标题并移除 “Title:” 前缀。
Extracts the paper title and removes the “Title:” prefix.

摘要 / Abstract

 abstract = meta_div.find("p", class_="mathjax")
 if abstract:
 paper["abstract"] = abstract.get_text(strip=True)

提取论文摘要。
Extracts the abstract text.

评论（可选） / Comments (Optional)

 comments_div = meta_div.find("div", class_="list-comments mathjax")
 if comments_div:
 comments_text = comments_div.get_text(strip=True)
 if "Comments:" in comments_text:
 comments_text = comments_text.split("Comments:", 1)[1].strip()
 paper["comments"] = comments_text

如果存在评论（例如 “10 pages, 3 figures”），则提取它。
Extracts comments if they exist (e.g., “10 pages, 3 figures”).

作者 / Authors

 authors_div = meta_div.find("div", class_="list-authors")
 if authors_div:
 authors = [a.get_text(strip=True) for a in authors_div.find_all("a")]
 paper["authors"] = authors

提取作者列表。
Extracts a list of author names.

学科分类 / Subjects

 subjects_div = meta_div.find("div", class_="list-subjects")
 if subjects_div:
 subjects_text = subjects_div.get_text(strip=True)
 if "Subjects:" in subjects_text:
 subjects_text = subjects_text.split("Subjects:", 1)[1].strip()
 paper["subjects"] = subjects_text

提取学科分类（例如 “Artificial Intelligence (cs.AI)"）。
Extracts the subject categories (e.g., “Artificial Intelligence (cs.AI)”).

添加到列表 / Adding to List

 if paper:
 papers.append(paper)

将论文字典添加到 papers 列表中。
Adds the paper dictionary to the papers list.

错误处理 / Error Handling

 except requests.RequestException as e:
 print(f"爬取失败: {e}")
 return []

捕获网络相关的错误，如果请求失败则返回空列表。
Catches network-related errors and returns an empty list if the request fails.

第四步：保存数据到文件 / Step 4: Saving Data to a File

def save_to_file(data, filename):
 with open(filename, "w", encoding="utf-8") as f:
 json.dump(data, f, ensure_ascii=False, indent=4)
 print(f"数据已保存到 {filename}")

save_to_file(): 将爬取的数据写入 JSON 文件。
Writes the scraped data to a JSON file.
ensure_ascii=False: 保留非 ASCII 字符（例如中文或特殊符号）。
Preserves non-ASCII characters (e.g., Chinese or special symbols).
indent=4: 格式化 JSON 文件以便阅读。
Formats the JSON file for readability.

第五步：主函数和执行 / Step 5: Main Function and Execution

def main():
 print("开始爬虫程序...")
 papers = crawl_arxiv_papers()

 if papers:
 save_to_file(papers, OUTPUT_FILE)
 print(f"爬取完成，共获取 {len(papers)} 篇论文信息")
 else:
 print("未获取到任何论文信息")

if __name__ == "__main__":
 main()

main(): 协调爬取和保存过程。
Orchestrates the crawling and saving process.
if __name__ == "__main__": 确保脚本仅在直接运行时执行（而不是被导入时）。
Ensures the script runs only when executed directly (not when imported).

运行代码 / Running the Code

将代码保存到文件（例如 arxiv_crawler.py）。
Save the code in a file (e.g., arxiv_crawler.py).
在同一目录下打开终端。
Open a terminal in the same directory.
运行脚本：
Run the script:
```
python arxiv_crawler.py
```
检查输出文件 arxiv_papers.json 查看结果。
Check the output file arxiv_papers.json for the results.

示例输出 / Sample Output

arxiv_papers.json 文件可能如下所示：
The arxiv_papers.json file might look like this:

[
 {
 "arxiv_url": "/abs/2503.12345",
 "arxiv_id": "arXiv:2503.12345",
 "title": "A New AI Model",
 "abstract": "This paper introduces...",
 "authors": ["John Doe", "Jane Smith"],
 "subjects": "Artificial Intelligence (cs.AI)"
 },
 ...
]

自定义建议 / Tips for Customization

更改类别 / Change Category: 修改 START_URL 来爬取其他 arXiv 类别（例如 https://arxiv.org/list/cs.LG/new 用于机器学习）。
Modify START_URL to scrape a different arXiv category (e.g., https://arxiv.org/list/cs.LG/new for Machine Learning).
添加延迟 / Add Delays: 在循环中加入 time.sleep(2) 以避免对服务器造成过大压力。
Use time.sleep(2) in the loop to avoid overwhelming the server.
错误日志 / Error Logging: 使用日志记录代替 print 语句，以便更好地调试。
Add logging instead of print statements for better debugging.

爬虫-实战-多页面递归爬取

Thu, 20 Mar 2025 10:20:00 +0800

import requests
from bs4 import BeautifulSoup
import json
from urllib.parse import urljoin
import time

# 配置爬虫参数
START_URL = "https://arxiv.org/list/cs.AI/new" # 替换为你想爬取的起始URL
MAX_DEPTH = 1 # 最大爬取深度
OUTPUT_FILE = "crawled_data.json" # 输出文件名

# 用于存储已访问的URL，避免重复
visited_urls = set()

# 用于存储爬取结果
crawled_data = []

def crawl(url, depth=0):
 # 检查深度限制和是否已访问
 if depth > MAX_DEPTH or url in visited_urls:
 return

 print(f"正在爬取: {url} (深度: {depth})")

 try:
 # 发送HTTP请求
 headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
 response = requests.get(url, headers=headers, timeout=20)
 response.raise_for_status() # 检查请求是否成功

 # 标记为已访问
 visited_urls.add(url)

 # 解析HTML内容
 soup = BeautifulSoup(response.text, "html.parser")

 # 提取当前页面的标题作为主要内容（可以根据需要修改）
 page_title = soup.title.string if soup.title else "无标题"

 # 提取页面中的内容
 content = soup.get_text()

 # 存储当前页面的URL和内容
 crawled_data.append({
 "url": url,
 "title": page_title,
 "depth": depth,
 "content": content
 })

 # 提取页面中的所有链接
 for link in soup.find_all("a", href=True):
 href = link.get("href")
 link_text = link.text.strip() or "无文本"

 # 将相对URL转换为绝对URL
 absolute_url = urljoin(url, href)

 # 简单过滤，只爬取http或https链接
 if absolute_url.startswith(("http://", "https://")):
 # 递归爬取新链接
 crawl(absolute_url, depth + 1)

 # 避免过于频繁请求，礼貌爬取
 time.sleep(1)

 except requests.RequestException as e:
 print(f"爬取 {url} 失败: {e}")

def save_to_file(data, filename):
 with open(filename, "w", encoding="utf-8") as f:
 json.dump(data, f, ensure_ascii=False, indent=4)
 print(f"数据已保存到 {filename}")

def main():
 print("开始爬取...")
 crawl(START_URL)
 save_to_file(crawled_data, OUTPUT_FILE)
 print(f"爬取完成，共爬取 {len(crawled_data)} 个页面")

if __name__ == "__main__":
 main()

1. 代码概述

这个爬虫使用 requests 获取网页内容，BeautifulSoup 解析 HTML，然后递归爬取页面中的链接，最终将结果保存为 JSON 文件。主要功能包括：

从指定起始 URL 开始爬取。
限制爬取深度，避免无限递归。
提取页面标题和文本内容。
保存爬取结果到本地文件。

2. 导入库

import requests
from bs4 import BeautifulSoup
import json
from urllib.parse import urljoin
import time

requests：用于发送 HTTP 请求获取网页内容。
BeautifulSoup（来自 bs4）：解析 HTML 内容，提取所需数据。
json：将爬取结果保存为 JSON 格式。
urljoin（来自 urllib.parse）：将相对 URL 转换为绝对 URL。
time：用于添加延迟，避免过于频繁请求服务器。

3. 配置爬虫参数

START_URL = "https://arxiv.org/list/cs.AI/new" # 替换为你想爬取的起始URL
MAX_DEPTH = 1 # 最大爬取深度
OUTPUT_FILE = "crawled_data.json" # 输出文件名

START_URL：爬虫的起始页面，这里是 arXiv 的 AI 分类新论文页面。
MAX_DEPTH：限制递归爬取的深度，防止爬虫无限扩展（这里设为 1，只爬取起始页面和其直接链接）。
OUTPUT_FILE：结果保存的文件名。

4. 全局变量

visited_urls = set()
crawled_data = []

visited_urls：一个集合（set），记录已访问的 URL，避免重复爬取。
crawled_data：一个列表，存储所有爬取到的页面数据。

5. 主爬取函数 `crawl`

def crawl(url, depth=0):

url：要爬取的网页地址。
depth：当前爬取的深度，默认从 0 开始。

5.1 检查条件

if depth > MAX_DEPTH or url in visited_urls:
 return

如果当前深度超过 MAX_DEPTH 或 URL 已访问过，则停止爬取并返回。

5.2 发送请求

print(f"正在爬取: {url} (深度: {depth})")
try:
 headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
 response = requests.get(url, headers=headers, timeout=20)
 response.raise_for_status() # 检查请求是否成功

打印当前爬取的 URL 和深度。
使用 requests.get 发送 HTTP GET 请求：
- headers：伪装成浏览器，避免被服务器拒绝。
- timeout=20：设置 20 秒超时，防止请求挂起。
raise_for_status()：如果请求失败（比如 404 或 500），抛出异常。

5.3 标记已访问

visited_urls.add(url)

将当前 URL 添加到 visited_urls 集合，避免重复爬取。

5.4 解析 HTML

soup = BeautifulSoup(response.text, "html.parser")

使用 BeautifulSoup 将网页的 HTML 内容解析为可操作的对象。

5.5 提取标题和内容

page_title = soup.title.string if soup.title else "无标题"
content = soup.get_text()

page_title：提取页面的 <title> 标签内容，如果没有则设为“无标题”。
content：提取页面所有文本内容（去掉 HTML 标签）。

5.6 保存数据

crawled_data.append({
 "url": url,
 "title": page_title,
 "depth": depth,
 "content": content
})

将当前页面的信息（URL、标题、深度、内容）存入 crawled_data 列表。

5.7 提取并递归爬取链接

for link in soup.find_all("a", href=True):
 href = link.get("href")
 link_text = link.text.strip() or "无文本"
 absolute_url = urljoin(url, href)
 if absolute_url.startswith(("http://", "https://")):
 crawl(absolute_url, depth + 1)

soup.find_all("a", href=True)：查找页面中所有带 href 属性的 <a> 标签（超链接）。
href：获取链接地址。
link_text：获取链接的文本内容，若为空则设为“无文本”。
urljoin(url, href)：将相对链接（如 /about）转换为绝对链接（如 https://arxiv.org/about）。
如果链接以 http:// 或 https:// 开头，则递归调用 crawl，深度加 1。

5.8 延迟

time.sleep(1)

每次请求后暂停 1 秒，避免对服务器造成过大压力（礼貌爬取）。

5.9 错误处理

except requests.RequestException as e:
 print(f"爬取 {url} 失败: {e}")

如果请求失败（如超时或 404），打印错误信息。

6. 保存数据函数 `save_to_file`

def save_to_file(data, filename):
 with open(filename, "w", encoding="utf-8") as f:
 json.dump(data, f, ensure_ascii=False, indent=4)
 print(f"数据已保存到 {filename}")

json.dump：将数据以 JSON 格式写入文件。
ensure_ascii=False：支持非 ASCII 字符（如中文）。
indent=4：格式化 JSON，使其更易读。

7. 主函数 `main`

def main():
 print("开始爬取...")
 crawl(START_URL)
 save_to_file(crawled_data, OUTPUT_FILE)
 print(f"爬取完成，共爬取 {len(crawled_data)} 个页面")

调用 crawl 开始爬取。
保存结果到文件。
打印爬取的总页面数。

8. 运行代码

if __name__ == "__main__":
 main()

确保代码只在直接运行脚本时执行（而不是被导入时）。

9. 运行示例

安装依赖：
```
pip install requests beautifulsoup4
```
运行代码：
- 爬虫从 https://arxiv.org/list/cs.AI/new 开始。
- 爬取该页面及其直接链接（深度 ≤ 1）。
- 结果保存到 crawled_data.json。

输出文件示例：

[
 {
 "url": "https://arxiv.org/list/cs.AI/new",
 "title": "New submissions for cs.AI",
 "depth": 0,
 "content": "...页面文本内容..."
 },
 {
 "url": "https://arxiv.org/abs/1234.56789",
 "title": "Paper Title",
 "depth": 1,
 "content": "...论文摘要等内容..."
 }
]

10. 注意事项

礼貌爬取：time.sleep(1) 避免过于频繁请求，但可以根据网站政策调整。
robots.txt：检查目标网站的 robots.txt（如 https://arxiv.org/robots.txt），确保遵守规则。
异常处理：当前只处理了请求相关的异常，可根据需要扩展。
内容提取：当前提取所有文本（get_text()），可改为提取特定元素（如论文标题、摘要）。

11. 改进建议

过滤链接：添加域名限制（如只爬 arxiv.org 的链接）。
多线程：使用 threading 或 asyncio 加速爬取。
数据清洗：去掉无关内容（如页脚、导航栏）。
代理支持：添加代理池以应对封禁。

一个自动签到的py并且使用github action每日执行

Mon, 03 Mar 2025 14:40:00 +0800

效果就是每天8点去自动签到

使用Cookie进行自动登录（简单，但是很容易因为Cookie过期而需要重新获取Cookie更新）

Cookie的获取

参考： https://www.diuber.com/cookie/

首先需要获取Cookie，这个Cookie是登录之后的Cookie，登录之后的Cookie是在浏览器的开发者工具中获取的，具体方法如下：

打开浏览器，登录mx的账号
打开浏览器的开发者工具，在Network中找到请求的接口，点击请求的接口，在Headers中找到Cookie，复制Cookie

签到的代码

# mx_checkin.py
import requests
import schedule
import time
from datetime import datetime
Cookie = os.environ.get("MX_COOKIE") # 把Cookie放置在action的环境变量中,例如这里是MX_COOKIE
# 签到函数
def checkin():
 # 替换为实际的签到接口 URL
 url = XXXXX

 # 准备请求头（可能需要 Cookie 或 Token 来验证身份）
 headers = {
 "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
 "Content-Type": "application/json",
 # 如果需要登录凭证，可以在这里添加 Cookie 或 Authorization
 "Cookie": Cookie,
 # "Authorization": "Bearer your_token_here"
 }

 # 准备请求数据（根据实际接口要求调整）
 data = {
 "userId": "your-user-id", # 替换为你的用户 ID
 "timestamp": int(time.time()) # 可选：发送当前时间戳
 }

 try:
 # 发送签到请求
 response = requests.post(url, headers=headers)
 response_json = response.json()

 # 检查签到是否成功
 if response.status_code == 200 :
 print(f"{datetime.now()} 签到成功：{response_json.get('msg')}")
 else:
 print(f"{datetime.now()} 签到失败：{response_json.get('msg')}")
 except Exception as e:
 print(f"{datetime.now()} 签到请求失败：{str(e)}")


# 脚本主循环
if __name__ == "__main__":
 print("自动签到脚本已启动...")
 # 首次运行时立即签到（可选）
 checkin()

代码写好之后可以先在本地测试，保证测试ok

github action的工作流配置

关于github action的内容，可以查看我的文章 github action使用

# mx_checkin.yml
name: mx_checkin

on:
 schedule:
 # 此处是UTC时间，对应北京时间早八点
 - cron : '00 00 * * *'
 workflow_dispatch:

permissions:
 contents: read

jobs:
 build:

 runs-on: ubuntu-latest

 steps:
 - uses: actions/checkout@v3
 - name: Set up Python 3.12
 uses: actions/setup-python@v3
 with:
 python-version: "3.12"
 - name: Install dependencies
 run: |
 python -m pip install --upgrade pip
 if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
 - name: Run checkin script
 run: |
 python mx_checkin.py
 env:
 MX_COOKIE: ${{ secrets.MX_COOKIE }}

requirements.txt

把需要的库写在这个文件中

requests
schedule
datetime

设置仓库密钥

把前面Cookie 填进去 粘贴过来的时候可以把引号去掉，我记得是不用加引号的，如果发现自己电脑上面测试可以，Action不行的话可以再试试加引号

上面的方法很受限于网站对于cookie的验证，如果网站对cookie验证过于严格，可以尝试下面的方法。

使用账号密码进行自动登录（复杂，但是可以避免Cookie过期的问题）

这里我只是给了一个简单的配置，很多网站登录的时候可能会多重验证，那就麻烦了….

找到登录的接口

当然每个网站不一样，不能一概而论

代码

# checkin
import requests
import schedule
import time
from datetime import datetime
import os
import json

from dotenv import load_dotenv
load_dotenv()


def refresh_cookie():
 """刷新 Cookie 的逻辑（需要根据实际网站实现）"""
 global Cookie
 try:
 # 替换为实际的登录 URL 和登录数据
 login_url = "https://mxwljsq.top/auth/login"
 login_data = {
 "email": os.environ.get("MX_EMAIL"), # 从环境变量获取邮箱
 "passwd": os.environ.get("MX_PASSWORD"), # 从环境变量获取密码
 }

 print(login_data)
 headers = {
 "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
 "Content-Type": "application/x-www-form-urlencoded"
 }
 # exit()
 # 发送登录请求
 response = requests.post(login_url, data=login_data, headers=headers)
 print(response.text)
 if response.status_code == 200:
 # 假设登录成功后 Cookie 在响应头中返回
 new_cookie = response.cookies.get_dict()
 Cookie = "; ".join([f"{k}={v}" for k, v in new_cookie.items()])
 print(f"{datetime.now()} Cookie 刷新成功")
 return True
 else:
 print(f"{datetime.now()} Cookie 刷新失败：{response.text}")
 return False
 except Exception as e:
 print(f"{datetime.now()} Cookie 刷新异常：{str(e)}")
 return False

def checkin():
 refresh_cookie()
 global Cookie
 if Cookie is None:
 print("Cookie 为空，请先刷新 Cookie")
 return False
 url = "https://mxwljsq.top/user/checkin"
 headers = {
 "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
 "Content-Type": "application/json",
 "Cookie": Cookie,
 }

 try:
 response = requests.post(url, headers=headers)
 response_json = response.json()

 if response.status_code == 200:
 print(f"{datetime.now()} 签到成功：{response_json.get('msg')}")
 return True
 else:
 print(f"{datetime.now()} 签到失败：{response_json.get('msg')}")
 # 如果是登录失效，尝试刷新 Cookie
 return False
 except Exception as e:
 print(f"{datetime.now()} 签到请求失败：{str(e)}")
 return False

if __name__ == "__main__":
 print("自动签到脚本已启动...")
 # 加载本地 Cookie，如果没有则使用环境变量中的
 # 首次运行立即签到
 print(f"{datetime.now()} 开始执行签到任务...")
 checkin()

# mx_checkin.yml
name: mx_checkin

on:
 schedule:
 # 此处是UTC时间，对应北京时间早八点
 - cron : '00 00 * * *'
 workflow_dispatch:

permissions:
 contents: read

jobs:
 build:

 runs-on: ubuntu-latest

 steps:
 - uses: actions/checkout@v3
 - name: Set up Python 3.12
 uses: actions/setup-python@v3
 with:
 python-version: "3.12"
 - name: Install dependencies
 run: |
 python -m pip install --upgrade pip
 if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
 - name: Run checkin script
 run: |
 python mx_checkin.py
 env:
 MX_EMAIL: ${{ secrets.MX_EMAIL }}
 MX_PASSWORD: ${{ secrets.MX_PASSWORD }}

设置仓库密钥

这里是肯定不需要加引号的，因为邮箱和密码都是字符串，加引号的话会被认为是字符串。（我试过了）

爬虫-基础介绍

Mon, 03 Mar 2025 00:00:00 +0800

介绍

以下是一些常见的 HTTP 状态码（因为它们在网络开发和日常使用中很常见）：

200 OK：请求成功，一切正常。
400 Bad Request：请求有问题，比如参数错误。
401 Unauthorized：未授权，需要登录或提供凭证。
403 Forbidden：服务器拒绝访问，权限不足。
404 Not Found：资源不存在，可能是URL错了。
500 Internal Server Error：服务器内部出错，程序或配置有问题。
503 Service Unavailable：服务暂时不可用，通常是服务器维护或过载。

关键要点

网络爬虫是一种自动浏览网页的程序，主要用于搜索引擎索引，但也用于数据挖掘和网页归档。
它从初始URL开始，下载页面，提取链接，递归访问，形成索引。
挑战包括资源消耗、重复内容和动态内容（如JavaScript页面）。
需遵循选择、重访、礼貌和并行化政策，确保高效和合规。
存在通用、聚焦和深网三种类型，法律和伦理问题需注意，如尊重robots.txt和数据隐私。

定义与目的

网络爬虫，也称为蜘蛛或机器人，是一种系统地浏览万维网以进行网页索引的程序。
它的主要目的是为搜索引擎更新内容或索引，帮助用户更高效地搜索。意外的是，它还用于网页归档、验证超链接和数据挖掘。

工作原理

爬虫从一组已知的URL（种子）开始，下载页面，提取其中的超链接，然后递归访问这些链接，依政策继续扩展。这种过程类似探索迷宫，但需管理大量数据。

示例Python代码

以下是一个简单的Python网络爬虫示例，使用requests和BeautifulSoup库，从给定URL开始，爬取页面上的所有链接并打印：

import requests
from bs4 import BeautifulSoup
from urllib.parse import urljoin, urlparse

def crawl(url):
 # 发送GET请求到URL
 response = requests.get(url)

 # 检查请求是否成功
 if response.status_code != 200:
 print(f"无法检索 {url}")
 return

 # 解析HTML内容
 soup = BeautifulSoup(response.text, 'html.parser')

 # 查找页面上的所有链接
 for link in soup.find_all('a'):
 # 获取href属性
 href = link.get('href')

 # 如果href为空，跳过此链接
 if href is None:
 continue

 # 将相对URL转换为绝对URL
 absolute_url = urljoin(url, href)

 # 打印绝对URL
 print(absolute_url)

 # 在实际应用中，可以将此URL添加到队列中以供后续爬取
 # 这里仅打印以简化

# 示例用法
start_url = 'https://www.example.com'
crawl(start_url)

此代码提供了一个基本框架，实际应用中需处理重复URL、遵守robots.txt等。

详细报告

网络爬虫是互联网技术的重要组成部分，广泛用于搜索引擎优化（SEO）、数据收集和网站监控。本报告将详细探讨其定义、工作原理、类型、挑战及相关政策，力求全面覆盖用户可能关心的所有方面，并附上Python代码示例。

定义与基本概念

根据Web Crawler - Wikipedia的定义，网络爬虫（也称为蜘蛛、蜘蛛机器人、蚂蚁、自动索引器或Web scutter）是一种系统地浏览万维网以进行网页索引（web spidering）的互联网机器人。
它的核心功能是复制网页内容，供搜索引擎索引，从而提升搜索效率。研究表明，爬虫不仅是搜索引擎的工具，还用于网页归档、验证超链接和HTML代码，以及数据驱动的编程。

工作原理与过程

爬虫的工作流程通常从一组初始URL（称为种子）开始。它会：

下载这些网页，提取其中的超链接。
将新发现的链接添加到爬取前沿（crawl frontier），然后递归访问。
根据预设政策（如选择政策、礼貌政策）决定下载哪些页面及访问频率。

例如，Cloudflare的解释指出，爬虫通过跟随链接“爬行”，类似于人类在网上点击导航，但自动化且规模庞大。
归档方面，爬虫会保存网页快照，存储在类似数据库的仓库中，但功能较数据库简单，通常以HTML文件形式保存。

覆盖范围与局限

互联网的页面数量极其庞大，研究显示（2009年数据），即使是最大的爬虫也只能索引40-70%的可索引网页，而1999年的研究显示仅16%Web Crawler - Wikipedia。
这一局限源于网页数量的爆炸性增长和高变化率，爬虫只能优先处理部分页面。

挑战与问题

爬取过程中面临多重挑战：

资源消耗：爬虫访问系统时会消耗网络和服务器资源，常未经提示访问，引发负载和礼貌性问题。
重复内容：由于HTTP GET参数的无限组合（如在线相册可能有48种不同URL，涉及排序、缩略图大小、格式和用户内容选项），难以避免重复下载Web Crawler - Wikipedia。
动态内容：AJAX页面等动态内容对爬虫构成挑战，Google提出可识别的AJAX调用格式以解决Web Crawler - Wikipedia。

爬取政策

爬取政策是爬虫高效运行的关键，分为以下几类：

选择政策：决定下载哪些页面，常用指标包括广度优先、反向链接计数和部分PageRank。研究（如Cho等，180,000页从stanford.edu爬取）显示，部分PageRank更适合早期捕获高PageRank页面，随后是广度优先和反向链接计数Web Crawler - Wikipedia。
重访政策：目标是最大化新鲜度（本地副本是否准确）或最小化年龄（本地副本多旧）。Cho和Garcia-Molina的研究表明，统一政策（所有页面同频率）优于按变化率比例分配的策略Web Crawler - Wikipedia。
礼貌政策：避免超载服务器，成本包括网络资源、服务器超载和由编写不佳的爬虫导致的崩溃。标准做法是使用robots.txt文件，建议访问间隔从60秒到3-4分钟不等，具体如Cho使用10秒，WIRE爬虫15秒，Mercator用10t秒（t为下载时间），Dill等用1秒Web Crawler - Wikipedia。
并行化政策：运行多个进程以最大化下载率，减少开销，避免重复下载，需政策分配新发现的URL。

以下是各类政策的对比：

政策类型	描述	示例/注意事项
选择政策	决定优先爬取哪些页面	广度优先、PageRank优先
重访政策	确定页面重访频率以保持数据新鲜	统一频率或按变化率调整
礼貌政策	避免超载服务器，遵守robots.txt	建议请求间隔1秒以上
并行化政策	使用多进程提升效率，管理资源分配	避免重复下载，优化爬取速度

类型的网络爬虫

通用爬虫：如Google和Bing的爬虫，目标是索引整个互联网。
聚焦爬虫：尝试下载相关页面，依赖通用搜索引擎作为起点。例如，学术爬虫如citeseerxbot（用于CiteSeer X）关注PDF、PostScript和Word文件，还有Google Scholar和Microsoft Academic SearchWeb Crawler - Wikipedia。
语义聚焦爬虫：使用领域本体进行更精准的爬取。

以下是各类爬虫的对比：

类型	特点	示例
通用爬虫	索引整个互联网，覆盖广	Googlebot, Bingbot
聚焦爬虫	针对特定主题或文件类型，效率高	citeseerxbot, Google Scholar bot
语义聚焦爬虫	使用本体，适合复杂领域	学术研究领域爬虫
企业爬虫	索引企业网站，供内部搜索使用	内部网站搜索引擎

安全与伦理问题

爬虫可能无意中索引非公共资源或暴露软件漏洞版本，缓解方法包括通过robots.txt限制搜索引擎仅索引公共部分，屏蔽交易部分Web Crawler - Wikipedia。
此外，爬虫通过HTTP请求的User-agent字段标识，管理员可通过日志和工具追踪，偏好标识以便在陷入爬虫陷阱或超载服务器时联系。垃圾邮件机器人可能掩盖身份，增加识别难度。

法律和伦理考虑包括：

尊重网站的服务条款和robots.txt文件。
避免以过多请求超载服务器（礼貌政策）。
负责处理个人数据，遵守隐私法。
透明地披露数据收集做法，尤其是涉及个人信息时。

深网爬取

深网（deep web）或不可见网包含大量仅通过数据库查询可访问的页面，常规爬虫需链接才能访问。策略包括：

Google的Sitemaps协议和mod oai。
屏幕抓取（screen scraping）用于跨表单聚合数据。
AJAX页面问题，Google提出可识别的AJAX调用格式Web Crawler - Wikipedia。

可视化与编程化

可视化爬虫/抓取工具降低了编程技能需求，通过高亮数据教学用户使用。例如，Needlebase（被Google作为ITA Labs的一部分收购，Needlebase）是典型代表，简化了数据提取过程Web Crawler - Wikipedia。

总结

网络爬虫是互联网信息获取的核心工具，其效率和伦理问题持续受到关注。未来，随着动态内容和深网的增长，爬虫技术需进一步创新，以平衡覆盖率和资源消耗。

爬虫实战 on 扎塔-Zata

ai-crawler-深度调研报告：人工智能驱动的网络爬虫技术——能力、应用与生态演进

深度调研报告：人工智能驱动的网络爬虫技术——能力、应用与生态演进

1. 执行摘要

2. 背景与技术范式转移

2.1 传统爬虫的局限性与“脆性”危机

2.2 生成式 AI 与大语言模型的介入

3. 核心技术能力与架构解析

3.1 基于 LLM 的 HTML 解析与非结构化数据提取

3.1.1 工作原理

3.1.2 DOM 降采样（Downsampling）与上下文管理

3.2 视觉驱动的提取与多模态融合

3.2.1 视觉页面分割（VIPS）

3.2.2 标记集提示（Set-of-Mark Prompting）

3.3 自主智能体（Autonomous Web Agents）

3.3.1 ReAct 范式与思维链

3.3.2 跨站协同与自我修复

4. 主流 AI 爬虫框架与工具深度评测

4.1 Firecrawl：RAG 数据管道的基石

4.2 ScrapeGraphAI：模块化与本地化的先锋

4.3 Crawl4AI：速度与开源的极致

4.4 Skyvern：视觉驱动的流程自动化

5. 对抗技术：反爬虫与防御机制的进化

5.1 行为生物识别（Behavioral Biometrics）

5.2 AI 抗性验证码（AI-Resistant CAPTCHAs）

5.3 “Agent 失明”危机（Blinded by the Agent）

6. 经济模型与成本分析

6.1 Token 经济学

6.2 维护成本的节省

7. 法律、伦理与合规新秩序

7.1 版权与“合理使用”的法律博弈

7.2 协议的演进：robots.txt vs ai.txt

7.3 GDPR 与隐私合规

8. 应用案例与行业影响

8.1 市场情报与动态定价

8.2 金融替代数据（Alternative Data）

8.3 销售线索生成（Lead Enrichment）

9. 未来展望：群体智能与 Agentic Web

9.1 多智能体群体（Multi-Agent Swarms）

9.2 协议化与“Agentic Web”的诞生

10. 结论

在 2024 年末到 2026 年初（当前时间点），“AI 爬虫”的概念已经发生了巨大的变化。

第一梯队：RAG 专用爬虫（目前最火）

1. Crawl4AI (Python)

2. Firecrawl

3. Jina Reader (r.jina.ai)

第二梯队：Agentic Web Browsers（智能操作型）

1. Stagehand

2. Skyvern

第三梯队：基础设施与抗指纹 (Infrastructure)

总结：我该选哪个？

下一步建议

AI 爬虫全景技术指南 (2025/2026 版)

1. 核心分类：根据需求选工具

2. 热门工具详解与代码思路

A. RAG 最佳拍档：Crawl4AI (Python)

B. 最简 API：Jina Reader

C. 复杂交互爬虫推荐：DrissionPage

D. 智能体方案：Browser-Use (LangChain + Playwright)

3. 针对“高难度”场景的解决方案

推荐技术栈排序

4. 模型选择：给 Agent 配个好大脑

💰 付费/最强王者

🆓 免费/平替方案 (推荐)

5. 总结建议

crawler-爬虫ip代理商

参考资料

代理商

快代理

亮数据

使用自己的VPN去做代理

爬虫中使用

crawler-tutorial

第一部分：主流爬虫框架/库对照

第二部分：高难度场景（验证码 + 强反爬）解决方案

告别手动写爬虫代码-从F12到Python

爬虫-实战-爬取arXiv AI论文对应的url和title等

教程：使用 Python 爬取 arXiv AI 论文 / Tutorial: Crawling arXiv AI Papers with Python

前提条件 / Prerequisites

代码功能 / What the Code Does

5. 主爬取函数 `crawl`

6. 保存数据函数 `save_to_file`

7. 主函数 `main`