Browserflow Documentation
Browserflow turns repeatable browser work into deterministic flows. Collect market data, find leads, fill forms, and execute actions. Teach the browser once, test your flow with new inputs, and connect the result to your stack.
Start with your own workflow or copy a shared flow from your Browserflow marketplace. Your flows and login profiles stay in your private workspace.
One Flow. Plug & Play with Your Favorite Tools.
Get started with official integrations built by Browserflow: our verified n8n node, Make app, and connections for ChatGPT and Claude. Connect your account, choose a published flow, and put it to work. The connections are built for Browserflow, so you do not need to build your own integration.
Record, test and publish your browser task once. Use it in an automation, run it from a conversation, or connect your own application with the API. Our MCP connection lets AI assistants discover and run the flows you enable, using the same Browserflow workspace.
All connections use your Browserflow workspace and its run limits. Publishing a flow does not automatically give an AI assistant access: you choose which flows and output fields it may use.
Start with one task: looking up a company, collecting a product list, or completing a form. Record it, name its inputs and outputs, then test the replay.
Choose your integration →Quickstart Guide
- Create your account and complete account setup.
- Choose Build Web Flow, enter a starting URL, and select a login profile if the website needs one.
- Use the website normally. Turn changing values into named inputs and select the data you want back.
- Save the recording and run a test. Review the actual output.
- Publish your tested flow and open Integrate to choose a connection.
Learn a Verified Web Automation
In Browserflow, you teach the browser by recording concrete actions. Replays follow those recorded steps with the inputs you supply. This makes the flow inspectable and repeatable; changes to a website or expired logins can still cause a run to fail.
Browserflow includes AI flow repair. If a recorded step can no longer find its target, repair compares the last working page with the current page and proposes an updated selection. In AI Settings, use Browserflow default, our managed connection to a third-party large language model (LLM), or connect your own model.
In Flow Settings, choose Approve draft to review repairs before using them, or Auto repair to let Browserflow validate a repair and continue the run. Repair requires a configured AI connection; a repaired version is saved only after a successful run. MCP runs use the exact approved version and stop for review instead of activating a repair during the run.
Create Your Flow
Open Build Web Flow in your dashboard. Give the browser a starting URL. If that address changes between runs, enable the start URL variable and choose its input name. Select a saved login profile or continue with public access.
The browser startup screen stays visible while your browser actually starts. If startup fails, return to setup and start again. An unfinished recording cannot be resumed after its browser closes.
Connect Your Published Flow
Open Integrate on a published flow. Choose Make, n8n, ChatGPT, Claude, Custom API, or MCP. Follow the setup guide for your integration and check its availability before connecting.
Make and n8n connect to your account and load the published flow's inputs. Custom API provides a URL and flow-specific key. AI assistants use an account connection plus your explicit approval for each published flow.
Inputs
Inputs are the values that change each time: a search phrase, company URL, product code, or form field. While recording, turn a navigation URL or typed value into a variable. Browserflow supports string, number, boolean, and secret inputs.
Use descriptive names such as company_url and
search_term. Supply required values when testing or
calling the API.
Results You Get Back
Choose Extract value for a single value, or a list for repeated items. Give every output a meaningful name. Actions can also run without extracting anything: the browser still performs the recorded clicks, selections, and form entries.
A successful action-only run returns an empty output
({}). Check the run status and Run history for the
outcome, or watch Live Viewer while it runs. If you expected data,
add a Scrape a list step or capture an output field. An empty output
by itself does not indicate success or failure.
Output List Mapping Across Thousands of Apps
Detect the repeated list, select the first field, and give it a
name. Add more fields or finish the list. The selection overlay
highlights matching fields across all rows and reports missing or
ambiguous matches. Optional missing fields remain
null on their own row.
Looping & Pagination
For multi-page lists, configure next-page navigation, a load-more button, or scrolling. Set limits for the number of items and pages. Browserflow returns up to 100 items per list in each run. Use Limit and Offset to collect more in batches. Recorded pagination can visit up to 50 pages, within the run time limit.
This follows the pagination you configure; it does not discover every link on a website automatically. Offset skips items through the recorded pagination; it does not change a website’s own API.
Session Viewer
The recorder shows the live browser, your recorded timeline, and the Browserflow coach. Navigate first, then switch to selection mode when the information you need is visible. Selection clicks choose fields without activating website links.
You can move or minimize the coach. Save or close the browser before leaving the recorder. Unsaved recordings do not survive a server restart.
Test Replay & Config Quality
Run a real test with representative inputs. A fresh browser opens, loads the selected login profile, and follows the recorded definition. Review the run status, any error, and the captured JSON before publishing.
For list batches, set Limit (maximum items per list) and Offset (items to skip, starting at zero). For example, use Limit 100 with offsets 0, 100 and 200. Leaving Limit empty uses the recorded list limits, capped at 100 items. Offset accepts 0–250,000 items to skip. Each list applies the window independently, following its recorded Next page, Load more or Scroll action. A nonzero Offset can traverse beyond the recorded page limit, subject to available data, runtime and browser resources. Each batch replays all recorded website actions; website ordering must remain stable between batches. Make exposes Limit and Offset in Run a flow; n8n exposes them under Options. API requests and MCP run_flow arguments accept them alongside inputs. ChatGPT and Claude use these same MCP controls.
Publication uses the exact definition and login profile that passed the test. After editing, test again before publishing a new version.
Integration Setup
These guides cover flows published in your Browserflow workspace at
browserflow.io. Start with a successfully tested,
published flow and complete your account setup, email verification
and subscription requirements.
The Studio Make app and n8n node update are being prepared for release. Existing Browserflow integrations may use an earlier flow format; use the Studio version described below when it is available to your account.
Connect ChatGPT and Claude through MCP. Follow the guides below to connect your account and choose which flows and results your assistant can use.
- API, call a published flow from your own application.
- Make, add browser work to a scenario.
- n8n, run a flow from an automation workflow.
- MCP, choose the flows and results your AI assistants can use.
- ChatGPT, connect Browserflow and request runs in a conversation.
- Claude, connect Browserflow through a remote connector.
Two connection methods, four platform integrations. The API and MCP are general ways to use your published flows. Make and n8n use the account API; ChatGPT and Claude use MCP. Your own application can use the flow API, and another compatible MCP client can connect after its OAuth registration is configured. All of these use the same Browserflow execution system.
Runtime & Billing
Browserflow Unlimited includes one user and 10 hours of runtime per billing month. View your usage, remaining hours and renewal date in Account settings. The month follows your Stripe subscription, rather than the calendar month. The seven-day trial has a separate 10-hour allowance.
Flow runs and test runs count, including runs through the API, MCP, Make and n8n. Website waits and failed executions use runtime; queueing and manual recording do not. Unused hours do not roll over. At the allowance limit, new executions pause while already-started runs may finish within their existing time limit. Your saved work and billing settings remain available while your subscription is active.
Add 10 hours for the current pack price per month on the same account. During a billing month, extra hours and cost are prorated; review both before confirming. Hours become available after successful payment. Decreases take effect at renewal. Runtime packs do not add users or simultaneous browser capacity.
Make: Run a Flow in a Scenario
Quick start from the homepage: click the Make card to copy a starter scenario using Make’s built-in HTTP module. In a new Make scenario, right-click the canvas and choose Paste. Open the module and replace its URL, Bearer key and JSON inputs with the values shown under your published flow’s Integrate → Custom API tab. Keep the key in Make, not in an AI chat or a shared blueprint.
This starter submits one run. It does not wait for completion. Read
its resultUrl with a later GET request using the same
Bearer key, and use the output only after succeeded.
Check the existing run while it is queued or running; do not submit
another POST to check progress. Configure the scenario before
running or scheduling it.
Availability: the Studio app is in private preparation. These instructions apply to its Run a flow, Get a run and Make an API call modules.
- Open a scenario and add Browserflow → Run a flow using the Studio app supplied for your account.
-
Create a connection and save it to open Browserflow sign-in. Sign
in at
browserflow.io, review the requested access and approve the connection. You do not copy a flow API key into this connection. -
Select your published flow. Map values from the previous module to
its named inputs, such as
search_term. -
Run the scenario once and check the returned status. Use the
Output fields in following modules only after
succeeded.
Longer runs: Run a flow checks for completion for
about 20 seconds. If the result is still queued or
running, keep its run ID. Add
Get a run with the same flow and run ID after a
delay; check again until it succeeds or fails. Do not start the flow
again just to retrieve its result.
Example: receive a company name from a form, map it to your flow's search input, then send the returned company details to your next module. For a list, use a Make Iterator to process the returned rows individually.
Advanced: Make an API call uses the existing connection for relative Browserflow account API paths. If you supply an idempotency key to Run a flow, keep it stable for an uncertain request and use a new key only for an intentional new run.
Reselect the flow after publishing changed inputs or outputs so Make reloads its fields. Revoke access in Browserflow → Account → Connected apps.
n8n: Add Browserflow to a Workflow
Homepage starter: click the n8n card to copy a
workflow with a built-in HTTP Request node. Paste into an empty n8n
canvas, then set the URL and JSON inputs from your published flow’s
Integrate → Custom API screen. Create a Header Auth
credential with Name Authorization and Value
Bearer YOUR_FLOW_API_KEY, replacing the placeholder
with your flow’s key, and select it in the node. This starter
submits one run; retrieve progress and output with a later GET
request to its resultUrl using the same key. Only use
the output after succeeded; do not repeat the POST to
check progress.
Availability: the Studio update to
n8n-nodes-browserflow is awaiting publication and
review. These steps use Browserflow version 2 with
OAuth. Older LinkedIn and endpoint-based nodes have different setup.
- Have your n8n owner or administrator install the Studio-compatible Browserflow node when released. Add Browserflow to the workflow and select version 2.
-
Create a Browserflow OAuth2 API credential and
choose Connect. Sign in at
browserflow.ioand approve access. No flow API key or client secret is required. - Choose a published flow and map its input fields from previous nodes.
- Execute the node. It waits for the run and returns its output for subsequent nodes. Inspect the returned data before enabling the complete workflow.
Example: use a schedule to run a product-price flow, supply the product URL from an earlier node, and pass the extracted price to a spreadsheet node. Start with one test item before processing a list.
Self-hosted n8n: send Browserflow the exact OAuth Redirect URL displayed in your n8n credential so it can be registered before connecting. Never send your password or token. n8n Cloud uses its workspace's HTTPS callback automatically.
If version 2 or the OAuth credential is missing, check that you have the Studio-compatible release. Installation may require an administrator; see n8n's community-node installation guide. Disconnect in Browserflow → Account → Connected apps.
MCP: Connect Clients and Choose Available Flows
MCP lets an AI assistant discover and run the published Browserflow flows you approve. You connect your account once, then expand the available flow catalogue by enabling more flows. Each flow uses the same Browserflow execution system as the API.
First, prepare your flow in Browserflow
- Sign in to Browserflow. Clone a flow from the marketplace into your workspace, or record your own. If the website requires a login, select your own saved login profile for the flow.
- Test the flow with the inputs you want to use, check the results, and publish the tested version. A saved draft alone is not ready for an integration.
- Open the flow's Integrate screen and select Claude or ChatGPT. You can also select MCP for the general connection instructions.
- Under Choose what your assistant can use, review the flow description and inputs, select the output fields you want to share, and turn on Available to AI assistants. Click Save access and continue.
- The connection instructions now appear below. On the Claude or ChatGPT tab, expand Connect with an MCP server address instead and click Copy address. On the MCP tab, the address is shown directly.
- Follow the Claude setup below or the ChatGPT setup to connect your Browserflow account. You only need to connect once; enable each additional published flow using the same steps above.
The app may call this a Browserflow plugin. For the setup
described here, add a custom MCP connection using
https://browserflow.io/mcp; you do not need to find a
Browserflow listing in the assistant's directory. The
Open Claude button opens Claude, but does not
install or connect Browserflow for you.
Available to AI assistants is one shared permission for the reviewed flow, not a separate switch for each assistant. Publishing alone does not enable it, and enabling it does not start a run or change API, Make or n8n access. Saved website logins stay in Browserflow; do not paste passwords into your assistant.
The server address is https://browserflow.io/mcp. You
do not need to install or run an MCP server on your computer. Other
MCP clients require a supported, registered OAuth connection.
Connect another MCP client
Use a client that supports Streamable HTTP and OAuth. Before connecting, ask the Browserflow operator to register its client ID and exact HTTPS OAuth callback URL. Public clients must support authorization code with S256 PKCE and the MCP resource URL. Other clients are not registered automatically, and there is no self-service client-registration screen yet.
- Test, publish and enable the flow using the steps above.
- Add your account's MCP server URL to the registered client. Sign in to Browserflow and approve the requested permissions. A flow API key cannot replace this account connection.
- List available flows, inspect one, start it once with its reviewed version and inputs, then retrieve its result. The four tools and their parameters are described below.
- Manage or revoke the connection under Account → Connected apps.
A directory listing is not required for a custom connection. Client compatibility must be checked for each additional client; an MCP URL alone does not establish compatibility.
You control access. Flows start with AI access off. Enabling another flow adds it to your available catalogue without reinstalling the connection. Ask the assistant to list flows again to see changes. Publishing a new version, activating a repair, rolling back, or unpublishing clears its approval. Review and enable the new published version before using it through MCP. Editing a draft leaves the unchanged published version available.
Inputs and results. Flows with secret inputs cannot be enabled for AI assistants. Use a saved login profile for website sign-in, and keep passwords out of conversations. Only selected output fields are returned; extracted website content may still contain sensitive information, so review the actual data you select.
Run behavior. The assistant uses the exact version you reviewed. It cannot silently switch to a repaired version. Inspect failures in Browserflow before starting another run. Switching off AI access stops new runs; already accepted runs may finish. Disconnecting an app blocks further access but cannot undo website actions that already happened.
For developers: tools and result handling
Published-flow execution uses four tools. Nine additional recording tools help create and improve drafts after separate approval. Enabling flows expands the catalogue returned by the tools, rather than creating a separate tool or server for every flow.
-
list_flows: discover enabled flows; optionalsearch,cursorandlimit. FollownextCursorwhen present. -
get_flow: sendflow_idto inspect inputs, selected outputs, effects and the currentversionId. -
run_flow: sendflow_id, that version asversion_id, a stablerequest_idandinputs. It returns a run ID and status, not the final output. -
get_run: sendrun_id. RespectpollAfterSecondswhile waiting. Once successful, read the selected output and passnextCursorascursorto retrieve remaining pages.
Example run_flow arguments; replace identifiers with
those returned by discovery:
{
"flow_id": "FLOW_ID_FROM_LIST_FLOWS",
"version_id": "VERSION_ID_FROM_GET_FLOW",
"request_id": "company-lookup-001",
"inputs": { "search_term": "design studios" },
"limit": 100,
"offset": 0
}
Keep the same request ID, version, inputs, limit and offset when recovering an uncertain response. A changed request with the same ID conflicts; expired history does not trigger another run. Never automatically retry website work with a new request ID. Use a new request ID for each intentionally requested batch. The result cursor only pages through output from an existing run.
Results are limited to 32 KiB per tool response and may be paginated. Output entries identify a field and value, with an index for list entries. Inspect omission notices for values too large to return; do not assume an incomplete response is the full result. Results can only be read by the connection that started the run.
MCP uses OAuth with mcp:flows:read,
mcp:flows:run and mcp:runs:read.
Recording and improving drafts require the separately approved
mcp:flows:author permission. Flow API keys and REST
integration tokens cannot be used as MCP credentials.
ChatGPT: Connect and Use Browserflow
Connect Browserflow to ChatGPT using the custom MCP connection below. There is no official Browserflow directory plugin to install. Availability depends on your ChatGPT account and workspace policy.
-
Copy the start prompt from Browserflow's homepage and paste it
into ChatGPT. It checks access first, then offers numbered
choices: 1 to run a flow, 2 to record, or 3 to improve. Reply with
a number. The public server address is
https://browserflow.io/mcp. - Open ChatGPT Plugins. If Browserflow is already there, check its server address and refresh the tools on its details page.
-
If no Browserflow connection exists, choose the plus button, then
Add custom MCP server. Name it Browserflow, enter
the full server address including
/mcp, and choose OAuth authentication when asked. - Review the warning, create and install the connection, then sign in to Browserflow when prompted. To build or improve a flow, approve the additional recording permission when requested. You do not need an OpenAI API key or a copied flow API key.
- Return to your chat and reply Done. The assistant will look for the newly available Browserflow tools, check access and continue. You do not need to select Browserflow with @ first. No saved flows yet is a valid result.
The assistant uses supported setup tools where available. ChatGPT cannot control its own settings through Computer Use, so you may need to complete the custom connection form yourself. Sign-in and permission approval always remain with you. If setup gets stuck, tell the assistant which setting or non-secret error you see. It should help with that step, then check access again. Refreshing tools and approving access are separate: refreshing does not grant recording permission. Menu labels can vary; consult the official ChatGPT connection guide or your workspace administrator if custom connections are unavailable.
“Find my Browserflow company lookup flow. Show me the required inputs and what it does before running it.”
Then, after reviewing it: “Run it once with search_term set to design studios. Wait for the result and summarize the returned companies.”
Use your actual flow and input names. Review any website actions before approving a run. See OpenAI's current connection guide for menu changes and workspace requirements.
Claude: Connect and Use Browserflow
First complete the Browserflow steps above: test and publish your flow, open Integrate → Claude, save AI access, and copy the MCP server address. Then connect your account in Claude using the steps below.
Connect Browserflow to Claude once
- In Claude on the web or desktop, open Customize → Connectors → Add → Custom → Web. Some versions show + → Add custom connector instead.
-
Name the connector Browserflow and enter
https://browserflow.io/mcpas its remote MCP server URL. Choose Continue. - Review the detected authentication settings. Use OAuth and, when asked, choose Sign in now and Use Claude's published identity. You do not need to create a client ID, enter a client secret, or add a Browserflow API key or request headers.
- Add the connector and complete Connect if shown. Sign in to the same Browserflow account that owns your flow and approve the requested access. If Browserflow asks you to finish email verification or account setup, complete those steps and continue to the access approval screen.
- Return to Claude. In a chat, open + → Connectors and enable Browserflow for that conversation. Ask it to find your flow and show its inputs before running it.
An organization owner may need to enable the custom connector
first under Organization settings → Connectors.
Give them the name Browserflow and server URL
https://browserflow.io/mcp. Once it is available to
you, connect your own Browserflow account. If you cannot add the
connector, ask your owner to enable it before continuing.
Try your first flow
Replace the example name below with the name of your published flow:
“Find my Browserflow flow called Company lookup. Show me the inputs it needs and what it does. Do not run it yet.”
After checking the flow and supplying your inputs: “Run that flow once with these inputs, wait for it to finish, and show me the results.”
Claude runs the published flow in Browserflow using its saved login profile and the inputs you provide. The selected results return to your conversation. You do not need to rebuild the flow in Claude.
If your flow does not appear
- Check that Claude is connected to the Browserflow account that owns the flow.
- In Browserflow, check that the flow is published and that Integrate → Claude → Available to AI assistants is on and saved. Publishing a new version or activating a repair requires you to review and save access again.
- Enable Browserflow in the Claude conversation and ask Claude to list your flows again. If you are already connected, you do not need to add another connector for each flow.
Need help? Ask us in the Browserflow community and tell us which step you reached and the error message, without sharing passwords or keys. For Claude's current menu labels, see Claude's connector guide.
API: Start a Flow and Read Its Result
Open Integrate → Custom API on a published flow and copy its exact endpoint and Bearer key. Call it from your server or a trusted automation. Keep the key out of public frontend code.
1. Start a run. Replace the placeholders and use your flow's actual input names. Choose a unique idempotency key for each intended run.
curl --request POST 'https://browserflow.io/api/flows/YOUR_FLOW_ID/runs' \
--header 'Authorization: Bearer YOUR_FLOW_API_KEY' \
--header 'Content-Type: application/json' \
--header 'Idempotency-Key: company-lookup-001' \
--data '{"inputs":{"search_term":"design studios"},"limit":100,"offset":0}'
A newly accepted run returns HTTP 202. Example
response:
{
"id": "RUN_ID",
"status": "queued",
"resultUrl": "https://browserflow.io/api/runs/RUN_ID"
}
2. Read the result. Request the returned
resultUrl using the same key:
curl 'https://browserflow.io/api/runs/RUN_ID' \
--header 'Authorization: Bearer YOUR_FLOW_API_KEY'
If the status is queued or running, wait a
few seconds and read it again. Use output only after
succeeded. On failed, inspect
error and review the run in Browserflow. Your output
fields depend on the flow you recorded.
Avoid duplicate actions. If the start response is
lost, repeat the request with the same idempotency key and identical
inputs. An accepted replay returns the existing run with HTTP
200; use its id at
/api/runs/RUN_ID if no result URL is included. Reading
status never starts another run. Do not automatically start a new
run after a timeout or failure: earlier website actions may already
have happened.
Authentication Model
Dashboard access uses your account session. Flow API calls use a separate Bearer key scoped to the published flow, including its run results. Keep keys out of public pages and shared templates.
Account Integration API
Account integrations use https://browserflow.io and an
OAuth access token in the Authorization: Bearer header.
They can access the connected account's published flows and
integration runs. Drafts, login profile states and saved passwords
are not returned. Flow discovery and execution require an active
Browserflow subscription.
-
GET /api/v1/me: validate the connected account. -
GET /api/v1/flows: list published flows and their input definitions, without default values. Requiresflows:read. The response contains aflowsarray; this endpoint is not paginated. -
GET /api/v1/flows/FLOW_ID: retrieve one published flow's input definitions. Requiresflows:read. -
POST /api/v1/flows/FLOW_ID/runs: start a run with a JSON body such as{"inputs":{"query":"example"}}. Requiresflows:run. Returns HTTP 202 with the run'sid,flowIdandstatus. -
GET /api/v1/runs/RUN_ID: returnsid,flowId,status, and availableoutputorerror. The optionalerroris a plain text message, not an object. Requiresruns:read. Continue with output only when status issucceeded; queued or running jobs can be checked again later. Reading a run does not start another one.
For run requests, an optional Idempotency-Key header of
up to 128 characters prevents duplicate runs for the same
connection, flow and identical inputs. Reuse the key when retrying
an uncertain request. Reusing it with changed inputs returns HTTP
409. Expired run history returns HTTP 410 rather than starting the
job again. Invalid or revoked tokens return HTTP 401; insufficient
permissions return HTTP 403; unavailable flows or runs return HTTP
404.
OAuth token responses from POST /oauth/token include
access_token, token_type,
expires_in (3600 seconds), refresh_token,
refresh_expires_in (remaining grant lifetime in
seconds), and scope. Both authorization-code exchange
and refresh return these fields. Refresh rotates the refresh token;
store the newly returned token for the next refresh.
The Make modules load input fields from
GET /api/v1/make/flows/FLOW_ID/inputs and output fields
from GET /api/v1/make/flows/FLOW_ID/interface, both
with flows:read. The inputs endpoint returns a Make
field array containing a collection named inputs with
the named flow fields in its spec, or an empty array
for a flow without inputs. Run requests may omit inputs
when no inputs are needed. The interface endpoint declares
id, flowId, status,
error, and the typed output collection.
Published flow selection is intentionally fixed in each module so
Make can load that flow's input and output schema. The run ID in Get
a run can be mapped from a previous module. Select the flow again
after publishing a changed schema. Long runs may need a later
Get a run
module. Disconnect an integration in
Account → Connected apps to revoke its access.
Template API
Browse shared templates in your signed-in Browserflow marketplace. Preview the steps and inputs, then add an independent copy to your own flows. Templates do not include API keys, login profiles, previous run results, or publication history.
Manage and share templates through the Browserflow marketplace.
Publish & Reuse API
Test your flow successfully, then publish it using the final builder step or Publish as API. Publishing freezes that tested version. Later draft edits do not change the published version until you test and publish again.
AI assistant access must be reviewed again after changing the published version. See MCP flow access. Sharing to the marketplace is separate from API publication. Review the sanitized template before making it available to other Browserflow members.
Invoke Input Rules
Use the exact input names and types defined in the flow. Send them
inside inputs. A starting URL variable must contain a
valid supported URL. Secret inputs are supplied securely and are not
included in marketplace templates.
An optional Idempotency-Key header prevents duplicate
starts for an identical request. Reusing the key with different
inputs returns a conflict.
Metadata Output
A run reports queued, running,
succeeded, or failed. Read the actual
output after success. Failed runs include error
information to help locate the stopped step.
Check the result before using it downstream. A browser action may already have happened even if a later step fails.
Error Codes
A missing or invalid API key, or an unpublished flow, returns an authorization error. Invalid inputs produce validation errors. Reusing an idempotency key with different values returns HTTP 409. A failed browser run is reported in its run status and error.
Rate Limiting
Each account has one running job at a time and up to three browser sessions. Automated runs have a two-minute execution limit, extended to fifteen minutes when Offset is greater than zero. Sign-in and registration have a shared per-address rate limit. Build small, focused flows and avoid unnecessary polling.
Marketplace & Community
Share useful lead bots, market bots, and browser workflows. Other members can preview and copy them, then adapt their private copy. Your edits do not update an existing listing until you share it again.
Connection Help
- No flows appear: check that you signed in to the correct Browserflow account and published a successful test. For MCP, also enable AI access on the current published version and ask the assistant to list flows again.
- A flow disappeared after an update: a newly published or repaired version needs another AI access review. In Make, reselect the flow to reload changed input and output fields.
- The connection option is missing: check the rollout status, installed integration version and your host's account or administrator permissions.
- Sign-in does not finish: allow the login popup, complete Browserflow account setup and confirm access on the consent screen. Self-hosted n8n needs its exact callback registered. For an expired or revoked connection, connect again.
-
MCP cannot connect: copy the full URL from your
account, including
/mcp. A flow API endpoint, ordinary API key or localhost address is not a hosted MCP connection. -
A run is taking longer: keep its run ID and
retrieve its status. Do not trigger another run to check progress.
Respect rate-limit responses and any
Retry-AfterorpollAfterSecondsdelay. - A result field is missing: check the published output schema and the actual run result. For MCP, check selected output fields, remaining result pages and any omission notice.
- Stop an integration's access: disconnect it in Account → Connected apps. For AI access to one flow, switch off Available to AI assistants. Accepted runs may still finish; revocation cannot reverse completed website actions.
Operations & Troubleshooting
If a run stops, open Run history and inspect the error and page screenshots. Check whether the website changed, the login profile expired, a recorded step no longer finds its target, or an input is missing.
For selection failures, check the flow's repair settings and AI connection. With Approve draft, review the proposed repair on the flow card or in the run details, then approve it and start a new test or API run. With Auto repair, Browserflow can validate a repair and continue from the affected step. If a small fix is insufficient, its internal AI uses the same recorder to inspect the page, repair selections and record nested menu steps. The repaired steps and the rest of the run must pass before the changed version becomes active. If repair cannot be verified, the run stops for review. Earlier actions are not repeated. Actions that already started and timed out are not automatically retried. Renew expired login profiles or update the recording when needed, then test again.
Automatic CAPTCHA solving, uploads, downloads, drag-and-drop, and extraction inside iframes or shadow DOM are not supported.
Best Practices
- Start with one repeatable task and a clear outcome.
- Use named variables for changing values.
- Test optional or missing data and different inputs.
- Review actions and outputs before publication.
- Inspect shared templates before using your login profile.
- Keep credentials and API keys private.