网络爬虫需要多少代理？

网络搜索的代理计算事项为何

任何拆卸项目最先面对的一个问题是: 我到底需要几个代理人? 使用太少,你的IP 在几分钟内被禁用。 使用太多,你浪费预算 能力,你从来不碰。 正确的数字取决于您的目标站点,请求量,旋转策略,以及对块的容忍度.

此指南提供了一个实用的计算框架, 这样您可以自信地大小您的代理池, 无论是每天刮掉十页还是一千万页 。

如果你是新来的,从我们开始 完整网页搜索代理指南 基本概念。

核心公式

最简单的是,您需要的并行IP数量是:

required_ips = (requests_per_minute) / (safe_rpm_per_ip)

何处 安全( rpm per ip) 是单个IP可以在目标站点上维持的最大请求率,而不触发块. 这因具体目标而异:

示例计算

假设您需要每天从电子商务网站刮掉5万个产品页,在8小时的窗口内完成工作:

# Target: 50,000 pages in 8 hours
requests_per_minute = 50000 / (8 * 60)  # ≈ 104 RPM
safe_rpm_per_ip = 10                     # e-commerce average
required_ips = 104 / 10  # ≈ 11 concurrent IPs

在实际操作中,您应当添加一个 30-50%的缓冲 重试、失败和减速 所以现实的需要就在眼前 15-17 并行实施伙伴。 。 。

影响您的代理要求的因素

1. 目标地点

高级网站 反机器人系统 需要更多的IP,因为每个IP在被标记前可以提出较少的请求. 谷歌,亚马逊,以及主要社交平台在指纹和行为分析方面投入大量资金. 在针对这些地点时,用于3-5x个实施伙伴的预算比基准公式所示的多。

2. 请求量和频率

持续刮除(24/7监测)比批量作业需要更多的实施伙伴。 如果你每天运行一个批次, 你可以在窗口里积极旋转你的游泳池, 然后让IPs冷静下来。 为了实时监控,每个IP都保持活动时间更长,增加了你的总需求.

3. 地理分布

如果需要多个区域的数据(本地化定价,地理特异性搜索结果),在每个目标地理中都需要IP. 在10个国家实施一个刮掉价格的项目可能需要每个国家15个实施伙伴,即总共150个。 检查可用的 代理服务器位置 计划你的地理分布。

4. 会议与轮换要求

需要完成一些任务(登录流量、多页取出分析) 粘贴会议 同一个IP持续了几分钟。 这与实施伙伴的联系更长,减少了有效集合利用。 没有会话状态的纯数据收集可以在每次请求上旋转,更高效地使用每个IP.

5. 住宅与数据中心

住宅IP拥有更高的信任分数,可以在禁用前提出更多请求,因此你可能需要更少的. 但每GB成本更高. Datacenter IP更便宜但更快的标注,所以你需要一个更大的游泳池. 更深入的比较,见 住宅对数据中心对移动代理。 。 。

按使用大小写表

计算总宽度

代理计数为一维;带宽为二维. 估计您的数据传输总数 :

# Average page sizes
static_page = 50 KB      # HTML only
dynamic_page = 200 KB    # HTML + JSON/API responses
full_render = 2-5 MB     # with all assets (headless browser)
# Example: 50,000 pages/day × 200 KB average
daily_bandwidth = 50000 * 200 / 1024 / 1024  # ≈ 9.5 GB/day

这帮助你选择正确的 代理哈特计划 基于IP和带宽需要。

执行:动态集合大小

而不是静态猜测, 执行动态集合大小 适应现实世界的条件。 以下是使用具有适应性货币的代理Hat网关的例子:

Python 示例

import asyncio
import aiohttp
from dataclasses import dataclass, field
from time import time
@dataclass
class PoolSizer:
    """Dynamically adjusts concurrent proxy connections based on success rate."""
    min_concurrent: int = 5
    max_concurrent: int = 100
    target_success_rate: float = 0.95
    current_concurrent: int = 10
    results: list = field(default_factory=list)
    def record(self, success: bool):
        self.results.append((time(), success))
        # Keep only last 100 results
        self.results = self.results[-100:]
    @property
    def success_rate(self) -> float:
        if not self.results:
            return 1.0
        return sum(1 for _, s in self.results if s) / len(self.results)
    def adjust(self):
        rate = self.success_rate
        if rate >= self.target_success_rate and self.current_concurrent < self.max_concurrent:
            # Success rate is good — try more concurrency
            self.current_concurrent = min(self.current_concurrent + 2, self.max_concurrent)
        elif rate < self.target_success_rate * 0.9:
            # Success rate dropping — reduce concurrency
            self.current_concurrent = max(self.current_concurrent - 5, self.min_concurrent)
async def scrape_with_adaptive_pool(urls: list[str]):
    sizer = PoolSizer()
    proxy = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
    semaphore = asyncio.Semaphore(sizer.current_concurrent)
    async with aiohttp.ClientSession() as session:
        async def fetch(url):
            async with semaphore:
                try:
                    async with session.get(url, proxy=proxy, timeout=aiohttp.ClientTimeout(total=30)) as resp:
                        success = resp.status == 200
                        sizer.record(success)
                        return await resp.text() if success else None
                except Exception:
                    sizer.record(False)
                    return None
        for batch_start in range(0, len(urls), sizer.current_concurrent):
            batch = urls[batch_start:batch_start + sizer.current_concurrent]
            await asyncio.gather(*[fetch(url) for url in batch])
            sizer.adjust()
            # Update semaphore for next batch
            semaphore = asyncio.Semaphore(sizer.current_concurrent)
            print(f"Concurrent IPs: {sizer.current_concurrent}, Success rate: {sizer.success_rate:.1%}")

用于生产, 代理汉字 Python SDK 处理连接集和自动旋转。

节点.js 示例

const HttpsProxyAgent = require('https-proxy-agent');
const fetch = require('node-fetch');
class AdaptivePoolSizer {
  constructor(min = 5, max = 100) {
    this.min = min;
    this.max = max;
    this.current = 10;
    this.results = [];
    this.targetRate = 0.95;
  }
  record(success) {
    this.results.push({ time: Date.now(), success });
    if (this.results.length > 100) this.results = this.results.slice(-100);
  }
  get successRate() {
    if (!this.results.length) return 1;
    return this.results.filter(r => r.success).length / this.results.length;
  }
  adjust() {
    if (this.successRate >= this.targetRate && this.current < this.max) {
      this.current = Math.min(this.current + 2, this.max);
    } else if (this.successRate < this.targetRate * 0.9) {
      this.current = Math.max(this.current - 5, this.min);
    }
  }
}
async function scrapeWithAdaptivePool(urls) {
  const sizer = new AdaptivePoolSizer();
  const agent = new HttpsProxyAgent('http://USERNAME:PASSWORD@gate.proxyhat.com:8080');
  for (let i = 0; i < urls.length; i += sizer.current) {
    const batch = urls.slice(i, i + sizer.current);
    const results = await Promise.allSettled(
      batch.map(url =>
        fetch(url, { agent, timeout: 30000 })
          .then(res => { sizer.record(res.ok); return res.text(); })
          .catch(() => { sizer.record(false); return null; })
      )
    );
    sizer.adjust();
    console.log(`Concurrent: ${sizer.current}, Success: ${(sizer.successRate * 100).toFixed(1)}%`);
  }
}

缩放代理池时常见的错误

• 对所有目标使用相同的计数. 在亚马逊, 总是每个目标的基准。
• 忽略重试在上. 失败的请求会消耗带宽和时间 。 攻击目标重试率为20-40%
• 未计入会议要求。 如果登录流程需要粘性会话,则每个会话都会连接一个IP. 根据并行会话计算,而不仅仅是请求率.
• 忘却地域需求. 美国的十个IP不会帮助你刮去日本本地化的结果. 计划每个地理。
• 过度提供"以防万一"。 有了像ProxyHat这样的旋转式住宅代用品,你就可以自动进入一个大游泳池. 你支付带宽,而不是支付池内IP的数量. 重点 选择正确的代理类型 而不是囤积IP。

代理哈特优势: 池管理简化

由于代理代理网关为代理代理代理(ProxyHat)旋转,您不需要手动管理IP列表. 每个请求通过 gate.proxyhat.com 自动从百万的集合中接收到一个新鲜的IP. 这意味着:

• 没有手动IP列表管理
• 每次请求自动旋转( 或在需要时粘贴会话)
• 访问 IPs 在 190多个国家
• 使用带宽的付费,而不是每个IP收费

您的"代理计数"有效地成为您的货币级——您通过网关运行了多少个同时连接. 从上面的公式开始,然后让适应的缩放代码在生产中对其进行微调.

整个刮刮建筑 与代理,参见我们 完整网页搜索代理指南。学习辅助您的游泳池大小的旋转策略,读取 如何在不受阻的情况下搜索网站。 。 。

经常被问到的问题

我需要多少代理 小规模刮刮?

对于每天5 000项针对中度保护地点的小型项目,5-10个同时存在的住宅代管通常足够。 有了像ProxyHat这样的旋转网关,你只是将你的货币级设置为5-10,系统处理IP任务.

我需要更多JavaScript重型网站的代理吗?

对 无头浏览器刮刮速度较慢,每个请求(2-10秒对0.5-1秒只限HTML),这意味着每个并行的槽处理请求较少. 您可能需要2 - 3x 的货币来维持相同的吞吐量。 见我们的指南 避开块 用于优化提示。

我应该使用住宅或数据中心代理吗?

对于大多数拆卸任务,住宅代理的成功率较高,需要较少的并行连接。 数据中心代理每GB更便宜,但被封堵得更快,需要更大的池子. 读我们 代理类型比较 详细指导。

ProxyHat的旋转泳池是怎么工作的?

每个请求通过代理Hat的网关(gate.proxyhat.com:8080)被自动指定不同的住宅IP. 您不管理单个IP—— 您控制货币, 系统处理旋转 。 这比维持一个静态IP列表更有效.