BrowserForge：智能浏览器指纹与请求头生成器

简介

BrowserForge 是一个智能的浏览器请求头和指纹生成器，它使用贝叶斯生成网络来模拟真实世界中不同浏览器、操作系统和设备的分布频率。它是 Apify fingerprint-suite 的 Python 重新实现。

核心特性

  • 🎯 真实流量模拟 - 使用贝叶斯生成网络模拟实际网络流量
  • ⚡ 极速运行 - 运行时仅需 0.1-0.2 毫秒
  • 👤 简单易用 - 对人类友好的 API 设计
  • 🔧 高度可定制 - 支持浏览器、操作系统、设备、区域、HTTP 版本等定制
  • 🛡️ 类型安全 - 使用 Python 类型注解编写

安装

1
2
3
4
5
# 基础安装
pip install browserforge

# 完整安装（包含所有依赖）
pip install browserforge[all]

生成请求头

基础用法

1
2
3
4
5
6
7
8
from browserforge.headers import HeaderGenerator

# 创建生成器
headers = HeaderGenerator()

# 生成请求头
result = headers.generate()
print(result)

输出示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
    'sec-ch-ua': '"Chromium";v="142", "Google Chrome";v="142", "Not_A Brand";v="99"',
    'sec-ch-ua-mobile': '?0',
    'sec-ch-ua-platform': '"Windows"',
    'Upgrade-Insecure-Requests': '1',
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36',
    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
    'Sec-Fetch-Site': '?1',
    'Sec-Fetch-Mode': 'same-site',
    'Sec-Fetch-User': 'document',
    'Sec-Fetch-Dest': 'navigate',
    'Accept-Encoding': 'gzip, deflate, br, zstd',
    'Accept-Language': 'en-US;q=1.0, en;q=0.9, de;q=0.8'
}

与 requests 集成

1
2
3
4
5
6
7
8
9
10
11
12
13
import requests
from browserforge.headers import HeaderGenerator

# 创建会话
session = requests.Session()

# 生成请求头
generator = HeaderGenerator()
session.headers = generator.generate()

# 发送请求
response = session.get("https://example.com")
print(response.status_code)

与 aiohttp 集成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import aiohttp
import asyncio
from browserforge.headers import HeaderGenerator

async def fetch():
    generator = HeaderGenerator()
    headers = generator.generate()
    
    async with aiohttp.ClientSession(headers=headers) as session:
        async with session.get("https://example.com") as response:
            return await response.text()

# 运行
result = asyncio.run(fetch())

约束条件配置

单一约束

1
2
3
4
5
6
7
8
9
10
11
12
from browserforge.headers import HeaderGenerator

# 指定特定浏览器和操作系统
headers = HeaderGenerator(
    browser='chrome',
    os='windows',
    device='desktop',
    locale='en-US',
    http_version=2
)

result = headers.generate()

多约束选择

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from browserforge.headers import HeaderGenerator

# 从多个选项中选择（基于真实频率）
headers = HeaderGenerator(
    browser=('chrome', 'firefox', 'safari', 'edge'),
    os=('windows', 'macos', 'linux', 'android', 'ios'),
    device=('desktop', 'mobile'),
    locale=('en-US', 'en', 'de'),
    http_version=2
)

# 每次 generate() 会根据真实分布随机选择
for i in range(5):
    print(headers.generate()['User-Agent'])

浏览器版本控制

1
2
3
4
5
6
7
8
9
10
11
12
from browserforge.headers import HeaderGenerator, Browser

# 指定浏览器版本范围
browsers = [
    Browser(name='chrome', min_version=140, max_version=145),
    Browser(name='firefox', min_version=144),
    Browser(name='edge', max_version=140, http_version=1),
]

headers = HeaderGenerator(browser=browsers)
result = headers.generate()
print(result['User-Agent'])

基于现有 User-Agent 生成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from browserforge.headers import HeaderGenerator

headers = HeaderGenerator()

# 基于单个 User-Agent
result = headers.generate(
    user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36'
)

# 基于多个 User-Agent（按频率选择）
result = headers.generate(
    user_agent=(
        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:144.0) Gecko/20100101 Firefox/144.0',
        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36'
    )
)

生成浏览器指纹

基础用法

1
2
3
4
5
6
7
8
from browserforge.fingerprints import FingerprintGenerator

# 创建指纹生成器
fingerprints = FingerprintGenerator()

# 生成指纹
fp = fingerprints.generate()
print(fp)

指纹结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
Fingerprint(
    screen=ScreenFingerprint(
        availHeight=784,
        availWidth=1440,
        availTop=25,
        availLeft=0,
        colorDepth=30,
        height=900,
        pixelDepth=30,
        width=1440,
        devicePixelRatio=2,
        pageXOffset=0,
        pageYOffset=0,
        innerHeight=0,
        outerHeight=718,
        outerWidth=1440,
        innerWidth=0,
        screenX=0,
        clientWidth=0,
        clientHeight=19,
        hasHDR=True
    ),
    navigator=NavigatorFingerprint(
        userAgent='Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36',
        userAgentData={'architecture': 'arm', 'bitness': '64', ...},
        # ... 更多属性
    ),
    # ... 其他指纹信息
)

屏幕约束

1
2
3
4
5
6
7
8
9
10
11
12
13
from browserforge.fingerprints import FingerprintGenerator, Screen

# 定义屏幕约束
screen = Screen(
    min_width=1920,
    max_width=2560,
    min_height=1080,
    max_height=1440
)

fingerprints = FingerprintGenerator(screen=screen)
fp = fingerprints.generate()
print(f"Screen: {fp.screen.width}x{fp.screen.height}")

高级选项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from browserforge.fingerprints import FingerprintGenerator

fingerprints = FingerprintGenerator(
    screen=None,           # 屏幕约束
    strict=False,        # 约束过严时是否抛出异常
    mock_webrtc=False,   # 是否模拟 WebRTC
    slim=False,          # 是否禁用性能密集型规避
)

# 生成时覆盖选项
fp = fingerprints.generate(
    mock_webrtc=True,    # 启用 WebRTC 模拟
    slim=True            # 轻量模式
)

完整示例：爬虫请求轮换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import requests
import time
from browserforge.headers import HeaderGenerator

class StealthCrawler:
    def __init__(self):
        self.generator = HeaderGenerator(
            browser=('chrome', 'firefox', 'edge'),
            os=('windows', 'macos', 'linux'),
            device='desktop'
        )
        self.session = requests.Session()
    
    def fetch(self, url: str) -> str:
        """使用随机请求头获取页面"""
        # 每次请求更换请求头
        self.session.headers = self.generator.generate()
        
        try:
            response = self.session.get(url, timeout=30)
            response.raise_for_status()
            return response.text
        except requests.RequestException as e:
            print(f"Request failed: {e}")
            return None
    
    def crawl(self, urls: list):
        """批量爬取"""
        results = []
        for url in urls:
            print(f"Fetching: {url}")
            content = self.fetch(url)
            if content:
                results.append(content)
            time.sleep(2)  # 礼貌延迟
        return results

# 使用示例
if __name__ == "__main__":
    crawler = StealthCrawler()
    urls = [
        "https://example.com/page1",
        "https://example.com/page2",
        "https://example.com/page3",
    ]
    results = crawler.crawl(urls)
    print(f"Successfully fetched {len(results)} pages")

与 Playwright/Selenium 集成

Playwright 集成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from playwright.sync_api import sync_playwright
from browserforge.fingerprints import FingerprintGenerator

def main():
    # 生成指纹
    generator = FingerprintGenerator()
    fp = generator.generate()
    
    with sync_playwright() as p:
        # 使用指纹中的 User-Agent
        browser = p.chromium.launch()
        context = browser.new_context(
            user_agent=fp.navigator.userAgent,
            viewport={'width': fp.screen.width, 'height': fp.screen.height}
        )
        
        page = context.new_page()
        page.goto("https://example.com")
        
        browser.close()

if __name__ == "__main__":
    main()

Selenium 集成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from browserforge.headers import HeaderGenerator

def create_driver():
    # 生成请求头
    generator = HeaderGenerator()
    headers = generator.generate()
    
    # 配置 Chrome
    options = Options()
    options.add_argument(f"--user-agent={headers['User-Agent']}")
    options.add_argument("--disable-blink-features=AutomationControlled")
    
    driver = webdriver.Chrome(options=options)
    return driver

# 使用
driver = create_driver()
driver.get("https://example.com")
driver.quit()

参数参考

HeaderGenerator 参数

参数 类型 说明
browser str/list/Browser 浏览器类型
os str/list 操作系统
device str/list 设备类型
locale str/list 语言区域
http_version 1/2 HTTP 版本
strict bool 约束过严时是否报错

Browser 对象

1
2
3
4
5
6
7
8
from browserforge.headers import Browser

browser = Browser(
    name='chrome',        # 浏览器名称
    min_version=140,      # 最小版本
    max_version=145,      # 最大版本
    http_version=2        # HTTP 版本
)

相关资源

总结

BrowserForge 是一个轻量级但功能强大的指纹和请求头生成工具，特别适合需要模拟真实浏览器环境的爬虫和自动化任务。它的贝叶斯生成网络确保了生成的指纹符合真实世界的分布，而极快的运行速度使其适合高频请求场景。

💡 提示：BrowserForge 是 Camoufox 的底层指纹生成库，两者结合使用可以获得更完整的反检测浏览器解决方案。

技术笔记 > 网络请求
#BrowserForge #指纹生成 #请求头 #爬虫 #反检测 #Python
BrowserForge：智能浏览器指纹与请求头生成器
https://kingjem.github.io/2026/03/17/BrowserForge：智能浏览器指纹与请求头生成器/
作者
Ruhai
发布于
2026年3月17日
许可协议