AI浏览器如何降低成本｜附完整命令

在过去一年里，“AI浏览器”逐渐从概念走向实用：它可以像人一样打开网页、搜索信息、点击按钮、填写表单、整理资料，甚至完成一些重复性的运营、调研和办公任务。
但很多人真正开始使用后，很快会遇到一个现实问题：成本不低。

成本主要来自三部分：

1. 大模型调用成本：AI浏览器需要频繁理解页面、规划动作、判断下一步，Token 消耗很快。
2. 浏览器执行成本：如果使用云端浏览器、远程环境、RPA 平台，可能按时长或任务收费。
3. 试错成本：网页结构复杂，AI一次操作失败后会反复重试，导致 Token 和时间进一步增加。

本文将从实战角度介绍：如何搭建一个相对低成本的 AI 浏览器工作流，并附上完整命令。你可以用它完成网页搜索、信息整理、简单表单操作、竞品调研等任务。

一、AI浏览器为什么贵？

AI浏览器并不是简单地“打开网页”。一个完整流程通常包括：

用户目标
  ↓
大模型理解任务
  ↓
打开浏览器
  ↓
读取页面内容
  ↓
分析当前页面
  ↓
决定点击、输入、滚动、搜索
  ↓
执行动作
  ↓
再次读取页面
  ↓
继续推理
  ↓
输出结果

每一步都可能调用大模型。

例如你让 AI 浏览器完成：

帮我搜索 5 家做企业知识库的产品，整理它们的官网、价格、主要功能和适合客户。

AI 浏览器可能需要：

• 打开搜索引擎；
• 输入关键词；
• 查看搜索结果；
• 打开多个网页；
• 阅读官网；
• 提取信息；
• 对比总结；
• 输出表格。

如果每个页面都把大量 HTML 或文本塞给大模型，Token 成本就会快速上涨。

二、降低成本的核心思路

要降低 AI 浏览器成本，不是简单地“换一个便宜模型”，而是要从整体流程优化。

核心策略有四个：

1. 能不用大模型的地方，就不用大模型

很多动作其实不需要大模型判断，例如：

• 打开固定网址；
• 搜索固定关键词；
• 截取页面文本；
• 提取标题、链接；
• 根据 CSS selector 点击按钮。

这些操作可以交给脚本完成，只把关键内容交给模型分析。

2. 使用小模型处理简单任务

不是所有任务都需要 GPT-4 级别模型。

可以按任务复杂度选择模型：

3. 减少页面输入内容

网页内容经常非常冗余，包括：

• 导航栏；
• 页脚；
• 广告；
• JS 脚本；
• 样式内容；
• 重复菜单；
• 推荐文章。

AI浏览器不应该直接把整个 HTML 发给模型，而应该先清洗内容。

4. 使用本地浏览器，而不是云端浏览器

如果你只是个人使用或内部自动化，完全可以在本地运行浏览器。
这样可以避免云浏览器、云 RPA、浏览器托管平台的额外费用。

三、推荐方案：Playwright + browser-use + 低价模型

本文使用一个常见的开源方案：

• Playwright：控制浏览器；
• browser-use：让大模型具备浏览器操作能力；
• LiteLLM / OpenAI 兼容接口：方便切换不同模型；
• 本地环境：降低云端浏览器成本。

说明：下面命令以 macOS / Linux 为主，Windows 用户可以使用 PowerShell 或 WSL。

四、环境准备

1. 安装 Python

建议使用 Python 3.11 或以上版本。

查看当前版本：

python3 --version

如果没有安装，可以使用以下方式。

macOS：

brew install python

Ubuntu / Debian：

sudo apt update
sudo apt install -y python3 python3-pip python3-venv

2. 创建项目目录

mkdir ai-browser-cost-down
cd ai-browser-cost-down

3. 创建虚拟环境

python3 -m venv .venv

激活虚拟环境：

macOS / Linux：

source .venv/bin/activate

Windows PowerShell：

.venv\Scripts\Activate.ps1

升级 pip：

python -m pip install --upgrade pip

五、安装依赖

安装 browser-use、Playwright、LangChain 相关依赖：

pip install browser-use playwright python-dotenv

安装 Playwright 浏览器：

playwright install chromium

如果是 Linux 服务器，还可以安装系统依赖：

playwright install-deps chromium

六、配置模型 API

为了降低成本，可以使用 OpenAI 兼容接口。很多模型服务商都支持类似格式。

创建 .env 文件：

touch .env

写入环境变量：

cat > .env << 'EOF'
OPENAI_API_KEY=你的_API_KEY
OPENAI_BASE_URL=https://api.openai.com/v1
AI_BROWSER_MODEL=gpt-4o-mini
EOF

如果你使用其他兼容 OpenAI 的服务，只需要改：

OPENAI_BASE_URL=你的服务商地址
AI_BROWSER_MODEL=你的模型名称

例如：

OPENAI_BASE_URL=https://api.example.com/v1
AI_BROWSER_MODEL=deepseek-chat

注意：不同服务商模型名称不同，请以你的服务商控制台为准。

七、最小可运行版本

创建文件：

touch run_browser.py

写入代码：

cat > run_browser.py << 'EOF'
import asyncio
import os
from dotenv import load_dotenv
from browser_use import Agent
from langchain_openai import ChatOpenAI

load_dotenv()

async def main():
    model = os.getenv("AI_BROWSER_MODEL", "gpt-4o-mini")
    base_url = os.getenv("OPENAI_BASE_URL")
    api_key = os.getenv("OPENAI_API_KEY")

    llm = ChatOpenAI(
        model=model,
        api_key=api_key,
        base_url=base_url,
        temperature=0,
    )

    task = """
    打开浏览器，搜索“AI浏览器 开源 项目”，
    找到3个相关项目，整理它们的名称、官网或GitHub地址、主要用途。
    最后用中文表格输出。
    """

    agent = Agent(
        task=task,
        llm=llm,
    )

    result = await agent.run()
    print(result)

if __name__ == "__main__":
    asyncio.run(main())
EOF

运行：

python run_browser.py

如果一切正常，你会看到浏览器被自动打开，并执行搜索、访问和整理。

八、第一轮降本：使用更便宜的模型

上面的代码默认使用：

AI_BROWSER_MODEL=gpt-4o-mini

你可以切换为更便宜的 OpenAI 兼容模型。

修改 .env：

cat > .env << 'EOF'
OPENAI_API_KEY=你的_API_KEY
OPENAI_BASE_URL=https://api.example.com/v1
AI_BROWSER_MODEL=deepseek-chat
EOF

再次运行：

python run_browser.py

这种方式最简单，但不一定最稳定。因为 AI 浏览器对模型的“规划能力”和“页面理解能力”要求较高。
如果模型太弱，可能会出现：

• 点击错误；
• 搜索失败；
• 无限循环；
• 页面读不懂；
• 输出内容不完整。

因此更推荐第二种方式：分层使用模型。

九、第二轮降本：复杂任务用AI，简单任务用脚本

很多时候，我们不需要让 AI 浏览器从头到尾自己操作。
例如搜索结果提取这件事，可以由 Playwright 完成，然后只把结果交给模型总结。

安装额外依赖：

pip install beautifulsoup4 requests

创建脚本：

touch search_collect.py

写入代码：

cat > search_collect.py << 'EOF'
import asyncio
from playwright.async_api import async_playwright

async def main():
    keyword = "AI浏览器 开源 项目"

    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page()

        await page.goto("https://www.bing.com", wait_until="domcontentloaded")
        await page.fill("textarea[name='q'], input[name='q']", keyword)
        await page.keyboard.press("Enter")
        await page.wait_for_load_state("domcontentloaded")
        await page.wait_for_timeout(3000)

        results = await page.locator("li.b_algo").evaluate_all("""
        nodes => nodes.slice(0, 10).map(node => {
            const titleEl = node.querySelector('h2');
            const linkEl = node.querySelector('h2 a');
            const descEl = node.querySelector('.b_caption p');
            return {
                title: titleEl ? titleEl.innerText : '',
                url: linkEl ? linkEl.href : '',
                description: descEl ? descEl.innerText : ''
            };
        })
        """)

        for i, item in enumerate(results, 1):
            print(f"{i}. {item['title']}")
            print(f"   {item['url']}")
            print(f"   {item['description']}")
            print()

        await browser.close()

if __name__ == "__main__":
    asyncio.run(main())
EOF

运行：

python search_collect.py

这个脚本的特点是：

• 不调用大模型；
• 只使用浏览器自动化；
• 成本几乎为零；
• 结果结构化。

然后你可以把这些搜索结果再交给模型总结。这样比让 AI 浏览器完整地搜索、阅读、判断要便宜很多。

十、第三轮降本：先清洗网页，再交给模型

假设我们要分析一个网页，不建议把完整 HTML 交给模型。
可以先提取正文文本。

创建文件：

touch extract_page_text.py

写入代码：

cat > extract_page_text.py << 'EOF'
import asyncio
import sys
from playwright.async_api import async_playwright

async def extract(url: str):
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page()
        await page.goto(url, wait_until="domcontentloaded", timeout=60000)
        await page.wait_for_timeout(2000)

        text = await page.evaluate("""
        () => {
            const removeSelectors = [
                'script', 'style', 'noscript', 'svg', 'canvas',
                'header', 'footer', 'nav', 'aside',
                '[role="navigation"]',
                '.nav', '.navbar', '.footer', '.sidebar',
                '.advertisement', '.ads', '.cookie'
            ];
            removeSelectors.forEach(sel => {
                document.querySelectorAll(sel).forEach(el => el.remove());
            });
            return document.body.innerText;
        }
        """)

        text = "\\n".join(
            line.strip()
            for line in text.splitlines()
            if line.strip()
        )

        print(text[:12000])
        await browser.close()

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("用法：python extract_page_text.py https://example.com")
        sys.exit(1)

    asyncio.run(extract(sys.argv[1]))
EOF

运行：

python extract_page_text.py https://example.com

这个脚本会：

• 删除脚本、样式、导航、页脚；
• 提取正文文本；
• 最多输出前 12000 个字符；
• 显著减少 Token 消耗。

如果一个网页原本有 200KB HTML，清洗后可能只剩几千字。
这对 AI 浏览器降本非常关键。

十一、第四轮降本：限制 AI 浏览器步数

AI 浏览器最容易烧钱的情况是陷入循环。
比如它一直点击、返回、再次点击，却没有完成任务。

所以必须限制最大执行步数。

修改 run_browser.py：

cat > run_browser.py << 'EOF'
import asyncio
import os
from dotenv import load_dotenv
from browser_use import Agent
from langchain_openai import ChatOpenAI

load_dotenv()

async def main():
    llm = ChatOpenAI(
        model=os.getenv("AI_BROWSER_MODEL", "gpt-4o-mini"),
        api_key=os.getenv("OPENAI_API_KEY"),
        base_url=os.getenv("OPENAI_BASE_URL"),
        temperature=0,
    )

    task = """
    搜索“browser-use GitHub”，找到项目主页。
    只需要输出项目名称、GitHub地址、项目简介。
    不要进行无关浏览。
    """

    agent = Agent(
        task=task,
        llm=llm,
    )

    result = await agent.run(max_steps=8)
    print(result)

if __name__ == "__main__":
    asyncio.run(main())
EOF

运行：

python run_browser.py

这里的关键是：

result = await agent.run(max_steps=8)

建议根据任务设置步数：

不要无限制运行。

十二、第五轮降本：让任务描述更明确

模糊的提示词会让 AI 浏览器反复尝试。

低效提示：

帮我看看这个产品怎么样。

高效提示：

打开 https://example.com，只分析首页内容。
提取以下字段：
1. 产品名称
2. 目标客户
3. 核心功能，最多5条
4. 是否有价格页
5. 一句话总结

不要点击无关链接。
如果没有找到信息，填写“未找到”。

越明确，越省钱。

你可以把任务模板写成这样：

你的任务是完成网页信息提取，不要进行开放式探索。

目标网址：{url}

只提取以下字段：
- 公司名称
- 产品名称
- 核心功能
- 价格信息
- 联系方式
- 适合客户

规则：
1. 最多浏览 3 个页面；
2. 优先查看首页、Pricing、About；
3. 不要点击博客、新闻、帮助中心；
4. 找不到的信息写“未找到”；
5. 最终用 Markdown 表格输出。

十三、第六轮降本：缓存结果，避免重复访问和重复调用模型

如果你经常分析同一批网站，应该缓存网页文本和模型结果。

创建缓存目录：

mkdir -p cache/pages cache/results

创建脚本：

touch cached_extract.py

写入代码：

cat > cached_extract.py << 'EOF'
import asyncio
import hashlib
import os
import sys
from playwright.async_api import async_playwright

CACHE_DIR = "cache/pages"
os.makedirs(CACHE_DIR, exist_ok=True)

def cache_key(url: str):
    return hashlib.md5(url.encode("utf-8")).hexdigest()

async def fetch_text(url: str):
    key = cache_key(url)
    path = os.path.join(CACHE_DIR, f"{key}.txt")

    if os.path.exists(path):
        print(f"[CACHE] {path}", file=sys.stderr)
        with open(path, "r", encoding="utf-8") as f:
            return f.read()

    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page()
        await page.goto(url, wait_until="domcontentloaded", timeout=60000)
        await page.wait_for_timeout(2000)

        text = await page.evaluate("""
        () => {
            document.querySelectorAll(
                'script, style, noscript, svg, canvas, header, footer, nav, aside'
            ).forEach(el => el.remove());
            return document.body.innerText;
        }
        """)

        text = "\\n".join(line.strip() for line in text.splitlines() if line.strip())

        with open(path, "w", encoding="utf-8") as f:
            f.write(text)

        await browser.close()
        return text

async def main():
    if len(sys.argv) < 2:
        print("用法：python cached_extract.py https://example.com")
        sys.exit(1)

    text = await fetch_text(sys.argv[1])
    print(text[:12000])

if __name__ == "__main__":
    asyncio.run(main())
EOF

运行：

python cached_extract.py https://example.com

第二次运行同一个网址时，就不会重新打开网页，而是直接读取缓存。

十四、第七轮降本：本地模型处理初筛

如果你的电脑配置允许，可以用 Ollama 跑本地模型，用于初步摘要、分类、筛选。

安装 Ollama：

macOS：

brew install ollama

Linux：

curl -fsSL https://ollama.com/install.sh | sh

启动服务：

ollama serve

拉取模型：

ollama pull qwen2.5:7b

测试：

ollama run qwen2.5:7b

安装 Python 客户端：

pip install ollama

创建本地摘要脚本：

touch local_summary.py

写入代码：

cat > local_summary.py << 'EOF'
import sys
import ollama

if len(sys.argv) < 2:
    print("用法：python local_summary.py page.txt")
    sys.exit(1)

with open(sys.argv[1], "r", encoding="utf-8") as f:
    text = f.read()[:8000]

prompt = f"""
请阅读以下网页文本，提取：
1. 产品名称
2. 目标用户
3. 核心功能，最多5条
4. 是否提到价格
5. 一句话总结

网页文本：
{text}
"""

response = ollama.chat(
    model="qwen2.5:7b",
    messages=[
        {"role": "user", "content": prompt}
    ]
)

print(response["message"]["content"])
EOF

使用方式：

python cached_extract.py https://example.com > page.txt
python local_summary.py page.txt

这样，初筛和简单总结可以完全本地完成，不产生 API 调用费用。

十五、推荐的低成本工作流

一个比较省钱、稳定的 AI 浏览器流程如下：

1. 用脚本打开网页或搜索结果
2. 提取结构化信息
3. 清洗页面正文
4. 缓存网页内容
5. 用本地模型或便宜模型做初筛
6. 只把关键内容交给强模型
7. 限制 AI 浏览器最大步数
8. 输出最终报告

对应成本变化大致如下：

十六、完整一键安装命令

如果你想快速搭建，可以直接执行下面这一组命令。

mkdir ai-browser-cost-down
cd ai-browser-cost-down

python3 -m venv .venv
source .venv/bin/activate

python -m pip install --upgrade pip
pip install browser-use playwright python-dotenv langchain-openai beautifulsoup4 requests ollama

playwright install chromium

Linux 服务器额外执行：

playwright install-deps chromium

创建 .env：

cat > .env << 'EOF'
OPENAI_API_KEY=你的_API_KEY
OPENAI_BASE_URL=https://api.openai.com/v1
AI_BROWSER_MODEL=gpt-4o-mini
EOF

创建运行文件：

cat > run_browser.py << 'EOF'
import asyncio
import os
from dotenv import load_dotenv
from browser_use import Agent
from langchain_openai import ChatOpenAI

load_dotenv()

async def main():
    llm = ChatOpenAI(
        model=os.getenv("AI_BROWSER_MODEL", "gpt-4o-mini"),
        api_key=os.getenv("OPENAI_API_KEY"),
        base_url=os.getenv("OPENAI_BASE_URL"),
        temperature=0,
    )

    task = """
    搜索“AI浏览器 开源 项目”，找到3个相关项目。
    输出字段：
    1. 项目名称
    2. 官网或GitHub地址
    3. 主要用途
    4. 适合什么用户

    要求：
    - 不要浏览无关页面；
    - 找不到的信息写“未找到”；
    - 最终用中文 Markdown 表格输出。
    """

    agent = Agent(
        task=task,
        llm=llm,
    )

    result = await agent.run(max_steps=10)
    print(result)

if __name__ == "__main__":
    asyncio.run(main())
EOF

运行：

python run_browser.py

十七、使用建议

如果你只是想体验 AI 浏览器，可以直接使用 browser-use 加一个便宜模型。
如果你想长期使用，建议不要让 AI 自由浏览，而是采用“脚本先行，模型补充”的架构。

具体建议如下：

1. 固定流程用代码，不用 AI 判断
   搜索、打开网页、提取标题、抓取正文，这些尽量用 Playwright 写死。

2. 开放式判断交给模型
   例如判断产品定位、总结卖点、对比优劣势。

3. 先用便宜模型，失败再升级强模型
   不要所有任务默认调用最贵模型。

4. 给 AI 浏览器设置最大步数
   防止循环操作导致成本失控。

5. 缓存所有中间结果
   包括网页文本、搜索结果、模型摘要。

6. 任务提示词要具体
   明确告诉 AI：访问哪些页面、提取哪些字段、不要做什么。

十八、总结

AI浏览器的价值很大，但如果使用方式不当，成本会非常高。
真正可持续的方案不是“让 AI 接管一切”，而是把任务拆开：

• 浏览器自动化负责执行；
• 脚本负责稳定流程；
• 本地模型负责初筛；
• 便宜模型负责普通理解；
• 强模型负责复杂判断和最终总结。

这样既能保留 AI 浏览器的灵活性，又能把成本控制在可接受范围内。

如果你是个人用户，推荐从：

Playwright + browser-use + gpt-4o-mini

开始。

如果你是团队内部使用，推荐升级为：

Playwright + 缓存 + 本地模型 + 低价API模型 + 强模型兜底

这才是更适合长期运行的低成本 AI 浏览器方案。