Fouradata Mcp

MCP浏览器工具

提供方 fouradata

浏览器工具 未标注 OAuth 授权 社区 / 第三方 CursorCodexZed

由 fouradata 提供的 MCP 服务器,未标注。

一句话选型结论

按资料字段整理

Fouradata Mcp 属于浏览器工具类 MCP 服务器,传输方式未标注,OAuth 授权,可直接接入 Cursor、Codex、Zed,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类浏览器工具 传输方式未标注 鉴权OAuth 授权 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

浏览器工具
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

web scraping proxy anti bot scraping data extraction crawler

支持客户端

适用场景

web scrapingproxyanti bot

安装与配置

未标注 OAuth 授权
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
自动操作网页

打开页面、点击、填表,把浏览器动作交给模型执行。

抓取结构化数据

把页面内容整理成表格或 JSON,省掉手工复制粘贴。

关键流程回归

按步骤检查页面是否正常,回归时少漏环节。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 已适配 Cursor、Codex、Zed,换客户端不用重新研究配置。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好OAuth 授权对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在浏览器工具场景里让模型直接调用外部能力的人。
  • 已经在用 Cursor、Codex 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Fouradata Mcp当前 未标注 未标注 未标注 无 未标注
Playwright MCP Server 21 stdio · 本地进程 本地部署 有 2026-05-18
Fetch 9a2682de 1 SSE · 服务端推送 支持远程部署 有 2026-05-18
Browser 738d52bc 未标注 stdio · 本地进程 本地部署 有 2026-05-17
MCP 40600ece 未标注 stdio · 本地进程 本地部署 有 2026-05-17
Skyvern MCP 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

浏览器工具
字段来自项目仓库与公开索引,中文说明由本站标注
提供方fouradata上游标注的维护方 fouradata
分类浏览器工具本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式OAuth 授权远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Cross-platform本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

19.2 KB
来自项目仓库与上游目录的原文,未做删改

FourA MCP

Reliable web access for AI agents.

Give your agent a public URL. FourA returns the content, whether the page needs a fast HTTP request,
proxy rotation, or a full browser session.

Start with foura_auto: one URL in, typed content out. It chooses the appropriate fetch method and handles common blocks for you. Use foura_single, foura_proxy, or foura_browser when you want explicit control over the request path.

Start simple Reach difficult pages Build predictable agent flows
One default tool for most URLs HTTP, proxy rotation, and full-browser rendering Typed outputs, stable error codes, and six ready-made prompts

The included workflows cover product extraction, article cleanup, price monitoring, endpoint checks, and bulk URL fetching.

Use it from Claude Desktop, Claude Code, Cursor, Windsurf, VS Code, or any MCP client. Run the npm package locally or connect to the hosted Streamable HTTP endpoint with the same FourA API key.

Get an API key · Read the MCP docs · See the package on npm

One-click install:

Both buttons pre-fill the config with a YOUR_FOURA_API_KEY placeholder - replace it with your key. Or by hand: claude mcp add foura -- npx -y @fouradata/mcp (set FOURA_API_KEY in env first). Full per-client setup below.

Quick Start - local stdio (recommended for Claude Desktop)

Create or reveal an API key at foura.ai/dashboard/#api-keys (format pk_live_...). Then drop this into your MCP client's config:```json
{
"mcpServers": {
"foura": {
"command": "npx",
"args": ["-y", "@fouradata/mcp"],
"env": {
"FOURA_API_KEY": "pk_live_..."
}
}
}
}


> **Claude Desktop gotcha:** fully quit Claude Desktop (`Cmd+Q` on macOS) **before** editing the config file. If the app is still running, it will overwrite your edits with its in-memory config on exit.

The npx command downloads the package on first launch and runs it as a subprocess of your MCP client. No global install needed. The same JSON works across MCP clients; only the config-file location changes:

| Client | Where the config lives |
|---|---|
| Claude Desktop (macOS) | `~/Library/Application Support/Claude/claude_desktop_config.json` |
| Claude Desktop (Windows) | `%APPDATA%\Claude\claude_desktop_config.json` |
| Claude Code | `claude mcp add foura -- npx -y @fouradata/mcp` (set `FOURA_API_KEY` in env first) |
| Cursor | `~/.cursor/mcp.json` |
| Windsurf | `~/.codeium/windsurf/mcp_config.json` |
| VS Code (MCP extension) | `.vscode/mcp.json` in your workspace |

Restart the client and `foura_auto`, `foura_single`, `foura_proxy`, `foura_browser` show up in your tool list, plus six prompts under `/prompts`.

## Quick Start - hosted (Streamable HTTP)

If your client supports the Streamable HTTP transport, point it at the hosted endpoint instead of running a local subprocess:```json
{
  "mcpServers": {
    "foura": {
      "url": "https://mcp.foura.ai/mcp",
      "headers": {
        "Authorization": "Bearer pk_live_..."
      }
    }
  }
}

For Claude Desktop, use the stdio config above. You can also bridge the hosted endpoint through mcp-remote:```json
{
"mcpServers": {
"foura": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://mcp.foura.ai/mcp", "--header", "Authorization: Bearer pk_live_..."]
}
}
}


## The Tools

`foura_auto` is the **default** - give it a URL and it returns the content, choosing the fetch method for you. The other three tools give you direct control over HTTP, proxy rotation, and browser rendering.

All four are marked `readOnlyHint: true` and `openWorldHint: true` per the MCP specification. Clients can use those annotations when deciding how to present or approve tool calls.

Every response carries human-readable text (`content`) plus a typed `structuredContent` JSON object validated against the tool's `outputSchema`. Your agent gets a predictable response contract instead of parsing prose.

### `foura_auto` - smart fetch (the default)

Give it a URL and get the content back. Use this first when you don't want to choose between HTTP, proxy rotation, and browser rendering. It handles common bot challenges and keeps the client surface small, with no proxy-attempt tuning required.```jsonc
{
  "url": "https://example.com",
  // optional: a substring the real page must contain, so auto can tell a
  // real page from a challenge page on protected targets
  "validate": { "data": { "accept": ["Example Domain"] } }
}

The client surface is intentionally minimal: url (required), plus optional method, headers, data, validate, returnSession (default true), forceProxy (default true), timeout_ms (5000-180000, default 120000), ignoreProxies, exitClass (standard or premium, as on foura_proxy).

structuredContent shape: {status, headers, data, meta, session}. meta is always present - {rung, solved, attempts, credits} - so your agent can see how the request completed and how many credits it used. session ({proxy, cookies, userAgent}) is returned by default for follow-up requests (pass session.proxy into the proxy field). Send returnSession: false to omit it. There is no total_time field on auto.

exitClass: "premium" lets auto escalate to a premium exit once the standard pool cannot reach the page, and the result's exitClass says which class delivered. The standard pool goes first; once the premium traffic in your plan is spent the call goes on in the standard pool and reports standard. Neither class is an error. On a plan without premium exits the call is refused with code: "plan_limit_premium". exitClass: "standard" keeps auto off premium exits.

foura_single - fast HTTP

One HTTP request, response back. Use it for static pages, JSON APIs, and server-rendered HTML. unblocker defaults to true, so the request already carries a full browser header set; set it to false for a plain HTTP request.```jsonc
{
"method": "GET",
"url": "https://example.com"
}


Supports custom headers, a body, per-stage timeouts, redirect controls, JSON auto-parse, a binary-buffer mode, and built-in response validation (`validate.status.accept`, `validate.data.fail`, and so on). If `foura_single` comes back blocked - status 403/429, a captcha page, challenge response headers, or a known challenge title - try a different browser profile (below), then escalate to `foura_proxy`. Start with `maxTries: 5`; protected targets may need `25-30`. If the page also needs JavaScript to render, pass `foura_proxy`'s returned `proxy` ID to `foura_browser.proxy`.

`structuredContent` shape: `{status, headers, data, total_time, ...}`. When the target ran a bot check, the response also carries `defense`; `defense.solved: false` means the body may be a challenge page rather than the content you asked for.

#### Choosing which browser you present

By default a request presents the latest Google Chrome. Some targets accept one browser and refuse another, so `foura_single` and `foura_proxy` let you pick:```jsonc
{
  "method": "GET",
  "url": "https://example.com",
  "browser": "Firefox",
  "os": "Windows"
}
  • browser - Chrome, Edge, Safari, Firefox, or Tor.
  • os - Windows, macOS, Android, or iOS. A family name accepts any of its versions; the exact labels in the catalogue narrow further.
  • version - any version the catalogue lists for that browser. The newest match wins when several fit.
  • profile - an exact id from the catalogue, when you already have one.

The full catalogue is public at api.foura.ai/api/profiles, no key required, and its default field names the profile a request gets when you ask for nothing. Selection needs unblocker on, which is the default. A combination that does not exist returns an error listing what is available, so a request is never quietly sent as a browser you did not choose.

foura_proxy - rotating proxies with retry

Same target shape as foura_single, but routed through rotating proxies with automatic retry on failure. Use it when a direct request is blocked or when the target requires a specific exit country.```jsonc
{
"maxTries": 5,
"exitCountries": ["CZ", "GB"],
"request": {
"method": "GET",
"url": "https://example.com/pricing",
"browser": "Chrome",
"os": "Windows"
}
}


`structuredContent` adds `proxy` (the encoded ID of the proxy that succeeded) and `total` (outer timing including selection and retries). When the rotation had to move to another browser to get an answer, `profile` names the catalogue profile it settled on; pass it as `profile` to present the same browser on the next call. `exitCountries` is optional: values are trimmed, uppercased, and deduplicated; proxies with unknown exits are excluded; the request never falls back to an unrequested country. Selection uses the latest available country metadata, normally updated within ten minutes, and a scoped success returns that value as `exitCountry`. If no eligible proxy matches, the result uses `code: "no_eligible_proxy"`.

The inner `request` takes the same browser-profile fields as `foura_single`: `browser`, `os`, `version`, or an exact `profile`.

**`exitClass` - for a target the standard pool cannot reach.** Set `exitClass: "premium"` and the request may escalate to a premium exit instead of only rotating within the standard pool. It is an allowance, not an instruction: the standard pool still races for the answer and usually wins, and a request it answers before any premium exit is tried costs no premium traffic. Once a premium exit has been tried, the traffic it carried counts toward your premium allowance even if that attempt failed; an attempt still running when another exit answered is stopped and not counted. The response reports `exitClass` back, `premium` or `standard`, so you can see per request which one served you. `standard` is also the answer once the premium traffic in your plan is spent, and it is a normal result, not an error. `exitClass: "standard"` forbids escalation outright. On a plan without premium exits the call is refused with `code: "plan_limit_premium"`.

**`attemptReport` - why a rotation ran out of tries.** Every failed `foura_proxy` result carries it beside the error. `summary` is one sentence; the counts underneath separate causes with opposite fixes: `noResponse` (the exit never answered), `defense` (a bot check was recognised, named in `vendors`), `contentRejected` (HTTP 200, no bot check, rejected only by your own `validate.data`), `statusRejected`, and `other`. `profilesTried` lists the browsers the task sent, in first-use order, with `default` meaning the request went out exactly as written. A high `contentRejected` means the pages arrived and your own rule threw them away: fetch one with `foura_single` and no `validate`, look at it, and rewrite the rule.

For difficult WAF challenges, use `maxTries: 25-30`. For a country allowlist, set `exitCountries` instead of increasing attempts. If the target needs JavaScript rendering, pass the returned `proxy` ID to `foura_browser.proxy`.

### `foura_browser` - full browser session

A real browser session. JavaScript runs, the DOM finishes rendering, cookies come back with the response. Use it when the page is a single-page app, when content lazy-loads after first paint, or when there's an anti-bot challenge that needs a real browser to clear.```jsonc
{
  "url": "https://example.com/spa",
  "timeout_ms": 15000,
  "checkText": "data-table"
}

Use this when an HTTP response isn't enough. checkText validates the rendered HTML once navigation completes; it doesn't wait or poll. If the substring is missing, the call fails with an error envelope. This catches pages that return 200 without the content you need. unblocker defaults to true and handles supported anti-bot or captcha challenges along the way. Set it to false to return the page exactly as it loads, challenge included.

structuredContent shape is intentionally different from single/proxy: {status, headers (object, not array), body (not data), cookies (full browser cookie shape), userAgent}.

Built-in Prompts

Six workflow templates surfaced under /prompts in your MCP client. They orchestrate one or more tools without you spelling out the steps.

Prompt Arguments What it does
smart_fetch url, must_contain?, extract? Pick the method, handle bot protection, and return or extract content
scrape_product_page url Extract title, price, image, stock, and SKU as JSON in a browser session
extract_article url Fetch an article, retry through a proxy if needed, and remove page chrome
monitor_pricing url, target_price? Fetch the current price and compare it with a target
check_endpoint_health url, expected_text? Validate reachability, status, content, and timing
bulk_fetch_urls urls (comma-separated) Fetch URLs in parallel, retry blocked ones, and return metadata

Each prompt arrives as a templated user message your LLM executes with the right tools. The full prompt text enters the context only when you invoke it.

Full recipe text + manual fallback prompts: foura.ai/docs/mcp/recipes. For the full error code list, see foura.ai/docs/mcp/errors.

Authentication

Use FOURA_API_KEY in stdio mode or an Authorization: Bearer pk_live_... header with the hosted endpoint. One key authenticates all four tools.

Keys are managed in the dashboard, where you can create, reveal, rotate, or deactivate them. See foura.ai/docs/getting-started/authentication for the full key-management walkthrough.

Error envelope - typed contract for agent retries

Every error (isError: true) carries a structuredContent envelope with at minimum these three fields:```jsonc
{
"service": "auto" | "single" | "proxy" | "browser",
"code": "ssrf_blocked" | "auth_failed" | "rate_limited" | ...,
"error": "Human-readable message"
}


Where the upstream returned a status, you also get `status` (HTTP code) and on rate-limit / capacity errors the FourA API envelope adds `retryAfter`, `current.{concurrency, rpm}`, `limits.{maxConcurrency, maxRpm}`.

| `code` | When | Retry safe? |
|---|---|---|
| `ssrf_blocked` | Target resolves to a private or reserved address | No - change the URL |
| `upstream_non_json` | Upstream returned malformed body | Maybe - investigate |
| `bad_request` (400) | Input shape rejected by FourA | No - fix arguments |
| `auth_failed` (401) | Key missing, invalid, or deactivated | No - fix the key |
| `forbidden` (403) | Authenticated but not allowed | No |
| `not_found` (404) | Target / endpoint doesn't exist | No |
| `rate_limited` (429) | RPM cap hit | Yes - wait `retryAfter` |
| `at_capacity` (503) | Concurrency cap hit | Yes - wait `retryAfter` |
| `service_disabled` (503) | Maintenance window | Yes - wait `retryAfter` |
| `service_unavailable` (503) | Generic 503 | Yes - short backoff |
| `upstream_error` (`>=500`) | Upstream 5xx | Yes - exponential backoff |
| `upstream_client_error` (4xx) | Other 4xx | Usually no |
| `no_eligible_proxy` | No proxy matches the requested `exitCountries` | No - change the country scope |
| `plan_limit_*` (403/429) | Your own FourA plan refused the call, not the target | Only `retryAfter` clears it - see below |

A `plan_limit_` code names which of your plan's limits refused the call: `credits`, `bandwidth`, `rate`, `concurrency`, `browser_daily`, `premium`, or `feature`. It is not the target blocking you, so retrying the same work through another tool spends the rest of the allowance for nothing. Wait out `retryAfter` where there is one, or change the plan.

LLM agents can read `code` directly for retry logic without parsing prose. Spec reference: foura.ai/docs/api/errors.

### What every result carries

Beside the tool's own fields, each result reports what the call cost and how to trace it:

- `credits` - credits this call spent, on failures as well, because the work was done either way;
- `request_id` - FourA's id for the call. Quote it in a support request;
- `exitClass` - `premium` when a premium exit served the call. On `foura_single` and `foura_browser` that happens when `proxy` replays a premium exit that `foura_proxy` or `foura_auto` found; on `foura_proxy` and `foura_auto` it is reported whenever the request named an `exitClass`.

## Combining the tools - reuse the same exit

The lower-level tools compose. `foura_proxy` returns the base36 ID of the exit it used. Pass that ID into `foura_single.proxy` or `foura_browser.proxy` to reuse the same exit for the next request.```jsonc
// 1. Find a working exit. Difficult protected targets may need maxTries:25-30.
const r = await foura_proxy({
  maxTries: 30,
  request: { method: "GET", url: "https://probe.example.com" }
});
// Returns { status: 200, proxy: "4DZ3VE", ... }

// 2. Reuse it for follow-up HTTP
await foura_single({ method: "GET", url: "https://target/api", proxy: r.proxy });

// 3. Or render JavaScript through the same exit.
await foura_browser({ url: "https://target/spa", proxy: r.proxy });

For a protected JavaScript page, find a working route with foura_proxy before calling foura_browser. Starting in the browser can return the challenge page before the real content loads.

To choose a different proxy on the next foura_proxy call, pass the previous ID as ignoreProxies: ["4DZ3VE"]. The proxy field on foura_single and foura_browser also accepts raw URLs (http://host:port, socks5://...) if you have your own list.

Large responses - offload_large (default: inline)

By default (since v0.2.0), full response bodies are returned inline in structuredContent regardless of size. This works in every MCP client.

If your client supports MCP resources/read (and you want to save tokens on big pages), pass offload_large: true per tool call. Responses of 50 KB or more are returned as a resource_link, and your client fetches the body only when it needs it. The resource remains available for one hour.jsonc { "method": "GET", "url": "https://en.wikipedia.org/wiki/Web_scraping", "offload_large": true // opt in for token savings }

Support for MCP resource links varies by client. Leave offload_large at its default false if your client can't read resource_link blocks.

Only the API key that created an offloaded resource can read it back.

Limits and responsible use

  • Private targets are refused. Requests to private or reserved addresses are blocked at the MCP layer. Only public-internet hosts are forwarded.
  • Rate limits are enforced by the FourA API per service. Concurrency + RPM. Details at foura.ai/docs/api/rate-limits.

Use FourA only for public content you are authorized to access and in accordance with the target site's terms and applicable law.

Run it yourself

Run the stdio server directly from npm with npx -y @fouradata/mcp, or build the included Dockerfile for the Streamable HTTP transport.

Configurable environment:

Variable Default Purpose
PORT 3076 HTTP listen port
FOURA_API_BASE https://api.foura.ai/api Upstream FourA REST base URL
FOURA_MCP_PAYLOADS_DIR /data/payloads Where responses of 50 KB or more are cached on disk

See DEVELOPMENT.md for the local build and test workflow.

License

MIT. See LICENSE.

Links

  • FourA (web scraping API):
  • MCP server page:
  • Source (GitHub):
  • npm package:
  • API documentation:
  • MCP server reference:
  • MCP error codes:
  • MCP recipes:
  • REST API errors:
  • MCP specification:
  • Get a key:

常见问题

7 问
答案由本站依据条目字段整理,不引用上游原文
Fouradata Mcp 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

Fouradata Mcp 怎么在 Cursor、Codex、Zed 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Fouradata Mcp 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Fouradata Mcp 需要 API Key 吗?

资料标注需要OAuth 授权认证,使用前准备好对应凭据,并按最小权限配置。

Fouradata Mcp 支持哪些客户端?

资料标注支持 Cursor、Codex、Zed;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Fouradata Mcp 能提供哪些能力?

资料显示能力标签包括 web scraping、proxy、anti bot、scraping、data extraction、crawler。具体工具清单以官方文档为准。

Fouradata Mcp 需要什么运行环境?

运行时为 Cross-platform。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。