mcp-flaresolverr
Provides tools for making HTTP GET and POST requests and managing persistent browser sessions through FlareSolverr, enabling bypass of Cloudflare anti-bot protection and retrieval of page content, cookies, and headers.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@mcp-flaresolverrfetch https://example.com behind Cloudflare protection"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
mcp-flaresolverr
A Node MCP (Model Context Protocol) server that exposes FlareSolverr's anti-bot bypass capabilities — Cloudflare and DDoS-GUARD protection — to any MCP client.
Installation
npx mcp-flaresolverrOr install globally:
npm install -g mcp-flaresolverrRelated MCP server: zenrows-mcp
Usage
Configure the server in your MCP client config and point it at your FlareSolverr instance:
{
"mcp": {
"servers": {
"flaresolverr": {
"command": "npx",
"args": ["-y", "mcp-flaresolverr"],
"env": {
"FLARESOLVERR_URL": "http://localhost:8191"
}
}
}
}
}Tools
Tool | Description |
| HTTP GET through FlareSolverr — returns page content, cookies, headers |
| HTTP POST through FlareSolverr — for form submissions and API calls |
| Create a persistent browser session for faster subsequent requests |
| Destroy a session and free resources |
| List all active browser sessions |
Configuration
Environment Variable | Required | Description |
| Yes | Base URL of your FlareSolverr instance (e.g. |
Development
npm install
npm run build
npm testLicense
MIT
Available Tools
5 toolsflare_getA
Make an HTTP GET request through FlareSolverr to bypass Cloudflare/DDoS protection. Returns the page content, cookies, and headers after the challenge is solved.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | ||
| proxy | No | Proxy configuration, e.g. {"url":"http://127.0.0.1:8888"} | |
| cookies | No | Cookies to send with the request, e.g. [{"name":"cookie1","value":"value1"}] | |
| session | No | Session ID to reuse a persistent browser instance | |
| maxTimeout | No | Max time in milliseconds to wait for the challenge to solve (default: 60000) | |
| disableMedia | No | If true, prevent loading images, CSS, and fonts to speed up navigation | |
| waitInSeconds | No | Seconds to wait after solving the challenge before returning (for dynamic content) | |
| returnScreenshot | No | If true, capture a screenshot of the solved page (Base64 PNG) | |
| tabs_till_verify | No | Number of Tab presses to reach a Turnstile captcha for manual verification | |
| returnOnlyCookies | No | If true, only return cookies instead of full page response | |
| session_ttl_minutes | No | Auto-rotate session after this many minutes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It usefully discloses the return payload (page content, cookies, headers) and that the challenge is solved before returning, but omits the operational traits an agent would want: that this is slow/heavy, session reuse behavior, timeout implications, and rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences, front-loading the core action (GET through FlareSolverr to bypass protection) followed by the return contract. No filler, every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For an 11-parameter tool with no output schema and no annotations, the description compensates by summarizing the return shape (content, cookies, headers) and the challenge-solving behavior. It is largely complete, though silence on session/timeout behavior and performance characteristics leaves minor gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 91%, so the schema already documents nearly all 11 parameters (proxy, cookies, session, maxTimeout, disableMedia, etc.). The description adds no parameter-level detail beyond what the schema provides, making the baseline 3 appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb+resource: an HTTP GET request via FlareSolverr, with the added purpose of bypassing Cloudflare/DDoS protection. The GET verb implicitly separates it from the flare_post sibling, but no sibling is named explicitly, so it falls just short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The bypass-Cloudflare framing implies when the tool is relevant, but there is no explicit when-to-use/when-not guidance and no routing to alternatives such as flare_post or the session tools. Usage is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
flare_postB
Make an HTTP POST request through FlareSolverr to bypass Cloudflare/DDoS protection. Useful for submitting forms or API calls behind protection.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | ||
| proxy | No | Proxy configuration | |
| cookies | No | Cookies to send with the request | |
| session | No | Session ID to reuse a persistent browser instance | |
| postData | Yes | POST body data in application/x-www-form-urlencoded format, e.g. 'a=b&c=d' | |
| maxTimeout | No | Max time in milliseconds to wait for the challenge to solve (default: 60000) | |
| returnOnlyCookies | No | If true, only return cookies instead of full page response | |
| session_ttl_minutes | No | Auto-rotate session after this many minutes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears the full burden. It discloses that the request is routed through FlareSolverr to bypass protection, implying potential latency and external dependency. However, it does not mention whether it is safe to retry, what the response contains, whether it mutates server state, or how sessions interact with calls — gaps for a networked POST tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the core action and mechanism. No wasted words, but could be tightened slightly by combining the purpose and use case into one sentence.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the fundamental operation but leaves out important behavioral context such as interaction with session persistence, error handling for unsolvable challenges, and what the caller can expect in the response. Given 8 parameters, no annotations, and no output schema, a more thorough behavioral note would help.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 88%, so the schema already documents most parameters well (e.g., postData format, session ID, maxTimeout). The description adds no parameter-level detail beyond what is in the structured schema. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'Make an HTTP POST request through FlareSolverr to bypass Cloudflare/DDoS protection.' This clearly distinguishes it from flare_get (GET vs POST) and the session management siblings. It lacks a bit of specificity around what the result looks like, but the core purpose is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It says 'Useful for submitting forms or API calls behind protection,' which gives a general use case but does not explicitly state when to choose this over flare_get or how to coordinate with session tools. No prerequisites or exclusions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
flare_session_createB
Create a persistent browser session. This speeds up subsequent requests since the browser doesn't need to launch a new instance for every request.
| Name | Required | Description | Default |
|---|---|---|---|
| proxy | No | Proxy configuration for this session | |
| session | No | Custom session ID. If not provided, a random UUID will be generated |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It discloses persistence and a performance rationale, but omits the lifecycle facts an agent needs: whether the session expires, whether it consumes resources that must be released, and whether the returned session identifier must be supplied to subsequent requests.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences with the core action front-loaded and the rationale second; nothing is padded. It is efficient, though it could have traded a few words for the missing lifecycle detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a state-creating tool with no annotations, no output schema, and a nested proxy object, the description is thin. An agent cannot tell how the new session ID is surfaced or how to consume it in flare_get/flare_post, nor whether cleanup is required, which are essential for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, including descriptions for the nested proxy object and the session ID parameter, so the schema does the heavy lifting. The description adds no parameter-level detail (e.g., how the generated session ID is returned or reused), so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Create a persistent browser session'), which is clear enough to distinguish from flare_session_destroy and flare_session_list. It does not explicitly name siblings or contrast its scope, so it stops short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The second sentence implies when to use it (before a series of requests, to avoid relaunching the browser), which is useful implied guidance. However, there is no explicit when-not, no mention of pairing with flare_session_destroy for cleanup, and no note on whether sessions must be reused via the returned ID.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
flare_session_destroyA
Destroy a browser session and free up resources. Always close sessions when done.
| Name | Required | Description | Default |
|---|---|---|---|
| session | Yes | Session ID to destroy |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. 'Free up resources' adds one useful trait, but it omits whether destruction is irreversible, what happens if the session is already gone, or whether the call is idempotent — key facts for a destructive operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the action and followed by the lifecycle hygiene note. No filler, no repetition of the schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter tool with no output schema and no annotations, the description covers purpose and a usage cue but leaves the destructive semantics (irreversibility, error on missing session) unstated. It is workable but not complete for a resource-destroying operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with a single required 'session' parameter that is already documented in the schema. The description adds no format, source, or lookup guidance beyond what the schema provides, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Destroy a browser session'), which unambiguously separates it from siblings flare_session_create, flare_session_list, and flare_get/flare_post. It does not explicitly name an alternative, but the destructive verb makes misselection unlikely.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Always close sessions when done' gives a clear condition for invoking the tool (session lifecycle end). There is no explicit statement of prerequisites or when-not-to-use, but the lifecycle guidance is concrete enough that an agent knows when to reach for it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
flare_session_listA
List all active browser sessions. Useful for debugging and monitoring.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. "List all active" does convey that it is a read-only enumeration of currently active sessions with no filtering or pagination, but it says nothing about permissions, return shape, or side effects. Low-risk no-param read tool, so the gap is moderate rather than severe.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the action and scope, with no filler. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema and no annotations, so the description could usefully say what a listed session contains or how many are returned, and it does not. For a trivial no-arg list tool this is acceptable but leaves a gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters and the schema is empty, so there is nothing for the description to disambiguate. Baseline of 4 applies for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (List) and resource (active browser sessions), which is enough to tell it apart from flare_session_create/destroy and flare_get/post at a high level. It does not explicitly name or contrast with any sibling, so it stops short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
"Useful for debugging and monitoring" implies a usage context but gives no when-to-use-vs-alternative guidance and no exclusions. An agent can infer it is a read-oriented enumeration tool, but nothing tells it when to prefer this over another session tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
5 tool updates
v1.0.0- First observed
flare_get - First observed
flare_post - First observed
flare_session_create - First observed
flare_session_destroy - First observed
flare_session_list
TDQS
Scored across 5 tools
Each tool has a clearly distinct purpose: two HTTP request methods (GET/POST) and three session management operations (list/create/destroy). No overlap or ambiguity; an agent can easily select the correct tool.
All tools use snake_case with a consistent 'flare_' prefix, but the pattern is mixed: session tools include the resource noun 'session' (e.g., flare_session_create) while HTTP request tools omit it (e.g., flare_get). Minor deviation, still readable.
Five tools is well-scoped for this domain: two core request methods and three session lifecycle operations. Each tool earns its place with no redundancy.
The surface covers the standard FlareSolverr API completely: GET/POST requests and session create/list/destroy. No obvious missing operations for the stated purpose.
Maintenance
Related MCP Connectors
Stealth web browser for agents: search, fetch, click, download and type in persistent MCP sessions.
Cloudflare Solver: Scraping API designed to bypass Cloudflare protection.
Browserless MCP — wraps the Browserless headless-Chromium REST API (browserless.io)
Web and URL utilities over MCP: shorten URLs, screenshot pages, read page metadata, encode URLs.
Related MCP Servers
- AlicenseAqualityDmaintenanceThis MCP server provides tools for interacting with Cloudflare Browser Rendering, allowing you to fetch and process web content for use as context in LLMs directly from Cline or Claude Desktop.511MIT

zenrows-mcpofficial
AlicenseAqualityCmaintenanceScrape any webpage and return clean markdown, HTML, or structured JSON. Bypasses anti-bot protection, renders JavaScript (React/Vue/Angular), supports premium residential proxies and CSS extraction. Works with any MCP client — no local install required.11,065 npm19MIT- FlicenseNot gradedqualityDmaintenanceA remote MCP server deployable on Cloudflare Workers without authentication, providing tools for website scraping and content extraction using Cloudflare's Browser Rendering and AI.1-
- AlicenseNot gradedqualityBmaintenanceRemote MCP server for web scraping with anti-bot evasion. Provides stealth HTTP fetching, headless browser with Cloudflare bypass, CSS selectors, YouTube transcripts, and Markdown conversion.1MIT