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.

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.

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.

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.

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, you can retry the same draft.

Open Integrate on a published flow. Choose Make, n8n, Custom API, or ChatGPT & Claude. 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 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.

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.

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.

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.

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.

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 within its page limit. 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.

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.

• 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.

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.

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.

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 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.

The AI assistant switch is the MCP access switch. In the current interface, MCP setup is grouped under ChatGPT & Claude. The Available to AI assistants setting enables the reviewed flow for authorized MCP connections, including other registered MCP clients. There is no second MCP switch, and it does not change API, Make or n8n access. It is one shared flow permission, not a separate ChatGPT or Claude selection.

1. Test and publish your flow.
2. Open Integrate → MCP → Review flow access, or Review access in the flow's settings.
3. Review its description, input names and types. Select only the output fields you want to share, enable Available to AI assistants, and choose Save access.
4. Open Account → Connected apps → MCP connection and copy the server URL. Follow the ChatGPT or Claude steps below, then approve Browserflow's account connection.

The hosted server URL is https://browserflow.io/mcp. Use the URL shown in your account. This is a remote connection; you do not need to run an MCP server on your computer. Other MCP clients require a supported, registered OAuth connection.

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.

{
  "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
}

Connect Browserflow to ChatGPT using the custom connection below. Availability depends on your ChatGPT account and workspace policy.

1. Complete Browserflow's MCP setup and copy the server URL from your account.
2. In ChatGPT, enable Developer mode under Settings → Security and login, if your workspace permits it.
3. Open Plugins, choose the plus button, and enter Browserflow as the name. Under Connection, use the full public MCP URL, including /mcp.
4. Create the connection, sign in to Browserflow when prompted and review consent and the discovered tools. The Browserflow connection does not require an OpenAI API key or a copied flow API key.
5. Start a conversation and add the connection from the tools menu. Ask ChatGPT to list your available Browserflow flows before choosing one to run.

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.

Connect Browserflow to Claude using a custom remote connector where your Claude plan and organization allow it.

1. Complete Browserflow's MCP setup and copy your server URL.
2. In Claude, open Customize → Connectors, choose + → Add custom connector, and enter the Browserflow URL. Leave optional client ID and secret fields empty for this connection.
3. Add the connector and choose Connect to sign in to Browserflow and approve access.
4. In a conversation, use + → Connectors to enable Browserflow. Ask Claude to list your available flows and inspect the one you want to use.

For Team or Enterprise, an owner first adds the URL under Organization settings → Connectors → Add → Custom → Web. Each member then connects their own Browserflow account.

This guide uses Claude's hosted remote connector. Keep the endpoint reachable over HTTPS; a localhost address on your computer will not work for this connection. See Claude's current custom-connector guide for account-specific steps.

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.

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 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.

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.

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.

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.

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.

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.

Each account has one running job at a time and up to three browser sessions. Runs have a two-minute limit. Sign-in and registration have a shared per-address rate limit. Build small, focused flows and avoid unnecessary polling.

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 →

• 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.

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. 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.

• 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.

• Create a workspace
• Your dashboard
• Browserflow marketplace
• Community
• Terms and privacy