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.

Your first result

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

  1. Create your account and complete account setup.
  2. Choose Build Web Flow, enter a starting URL, and select a login profile if the website needs one.
  3. Use the website normally. Turn changing values into named inputs and select the data you want back.
  4. Save the recording and run a test. Review the actual output.
  5. 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.

Integration availability

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.

  1. Open a scenario and add Browserflow → Run a flow using the Studio app supplied for your account.
  2. 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.
  3. Select your published flow. Map values from the previous module to its named inputs, such as search_term.
  4. 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.

  1. Have your n8n owner or administrator install the Studio-compatible Browserflow node when released. Add Browserflow to the workflow and select version 2.
  2. Create a Browserflow OAuth2 API credential and choose Connect. Sign in at browserflow.io and approve access. No flow API key or client secret is required.
  3. Choose a published flow and map its input fields from previous nodes.
  4. 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

  1. 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.
  2. 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.
  3. Open the flow's Integrate screen and select Claude or ChatGPT. You can also select MCP for the general connection instructions.
  4. 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.
  5. 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.
  6. 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.
Use the custom MCP connection

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.

  1. Test, publish and enable the flow using the steps above.
  2. 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.
  3. 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.
  4. 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.

  1. list_flows: discover enabled flows; optional search, cursor and limit. Follow nextCursor when present.
  2. get_flow: send flow_id to inspect inputs, selected outputs, effects and the current versionId.
  3. run_flow: send flow_id, that version as version_id, a stable request_id and inputs. It returns a run ID and status, not the final output.
  4. get_run: send run_id. Respect pollAfterSeconds while waiting. Once successful, read the selected output and pass nextCursor as cursor to 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.

  1. 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.
  2. Open ChatGPT Plugins. If Browserflow is already there, check its server address and refresh the tools on its details page.
  3. 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.
  4. 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.
  5. 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.

Try this with your own published flow

“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

  1. In Claude on the web or desktop, open Customize → Connectors → Add → Custom → Web. Some versions show + → Add custom connector instead.
  2. Name the connector Browserflow and enter https://browserflow.io/mcp as its remote MCP server URL. Choose Continue.
  3. 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.
  4. 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.
  5. 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.
Using Claude Team or Enterprise?

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. Requires flows:read. The response contains a flows array; this endpoint is not paginated.
  • GET /api/v1/flows/FLOW_ID: retrieve one published flow's input definitions. Requires flows:read.
  • POST /api/v1/flows/FLOW_ID/runs: start a run with a JSON body such as {"inputs":{"query":"example"}}. Requires flows:run. Returns HTTP 202 with the run's id, flowId and status.
  • GET /api/v1/runs/RUN_ID: returns id, flowId, status, and available output or error. The optional error is a plain text message, not an object. Requires runs:read. Continue with output only when status is succeeded; 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.

Meet the community → · Open your marketplace →

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-After or pollAfterSeconds delay.
  • 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.

Useful URLs

Great

Based on the reviews on Trustpilot

I use Browserflow daily with n8n

I use Browserflow daily with n8n, and it’s been a game-changer for my outreach and lead gen workflows. … The flows are visual, fast to build, and don’t break easily.

AH
Ash Hatef

Incredible support

Incredible support, amazing tool, saves time and effort. Perfect no code solution. Highly recommended

G
Glen

Great product & really friendly support...

Great product & really friendly support team that are happy to help with any issues

JC
Jamo Customs