# Account Settings
Source: https://docs.browseract.com/account-billing/account/account-settings



Account Settings currently supports changing your username and resetting your password. The email address linked to the account is displayed as read-only and cannot be changed.

## Open Account Settings

Open the account menu at the bottom of the BrowserAct dashboard and select `Account Settings`.

<img alt="Open Account Settings from the account menu" />

## Change Your Username

1. Update the `Username` field.
2. Select `Save Changes`.

## Reset Your Password

Select `Reset` beside the Password field and follow the password reset instructions.

<img alt="Change the username or reset the password" />

Your account email cannot currently be changed from Account Settings.


# Affiliate
Source: https://docs.browseract.com/account-billing/account/affiliate



Join the [BrowserAct Affiliate Program](https://www.browseract.com/affiliate) to create a permanent referral link, share BrowserAct with your audience, and earn commission from eligible purchases.

## Current Affiliate Offer

* Earn **30% commission** on a referred user's first order.
* Earn **20% commission** on that user's purchases during the following six months.
* Track clicks, registrations, purchases, and commission in the affiliate dashboard.
* Receive eligible payouts on a monthly schedule.
* There is no stated cap on total commission earnings.

## How to Get Started

1. Open the [BrowserAct Affiliate Program](https://www.browseract.com/affiliate).
2. Select `Get Started Now` and register for the program.
3. Get your referral link from the affiliate dashboard.
4. Share the link through tutorials, articles, communities, social posts, templates, or client recommendations.
5. Track referrals and eligible commission in the dashboard.

Affiliate terms, commission rates, attribution rules, and payout requirements may change. Review the current program page and affiliate dashboard before promoting BrowserAct.


# Redeem a Code
Source: https://docs.browseract.com/account-billing/account/redeem-code



Use `Redeem Code` to apply an eligible BrowserAct redemption code to your account.

1. Open the account menu in the lower-left corner of the BrowserAct dashboard.
2. Select `Redeem Code`.

<img alt="Enter a redemption code for the current BrowserAct account" />

3. Enter the redemption code.
4. Complete the redemption.
5. Review your balance or plan information to confirm the result.

If the code is invalid, expired, already used, or not eligible for the account, keep the code and error message and contact support.


# Task Failure Alert
Source: https://docs.browseract.com/account-billing/account/task-failure-alert



Task Failure Alert sends an email notification when the same Bot fails repeatedly. It helps you identify ongoing failures early and reduce the impact on scheduled or recurring tasks.

The alert is turned off by default.

## Enable the Alert

1. Open the account menu at the bottom of the BrowserAct dashboard.
2. Select `Task Failure Alert`.
3. Turn on `Task Failure Alert`.
4. Enter how many failures should trigger the notification.
5. Select `Save`.

<img alt="Enable Task Failure Alert and set the failure threshold" />

BrowserAct sends the alert after a single Bot reaches the configured number of failures. Set a threshold that helps you catch repeated problems without creating unnecessary notifications.

To stop receiving these notifications, return to `Task Failure Alert`, turn it off, and save the change.


# Billing & Credits
Source: https://docs.browseract.com/account-billing/billing/billing-credits



## How Credits Work

Credits are BrowserAct's unified billing unit. The same credit balance is used across BrowserAct services, including Agent Built Bot building and runs, Workflow Built Bot steps, Static Proxies, Dynamic Proxies, and local fingerprint browsers.

Different services consume credits in different ways:

* **Agent Built Bots:** Building and running a Bot consumes credits based on the task. Review the credits used in the related Task record.
* **Workflow Built Bots:** Each executed step consumes credits according to the Workflow step rules below.
* **Static Proxy:** Charged in credits per proxy per month. Pricing varies by location and tier.
* **Dynamic Proxy:** Charged by bandwidth at 5,000 credits per GB.
* **Local fingerprint browser:** Charged 100 credits each time a browser is created.
* **Cloud Browser:** Currently free for a limited time.

<img alt="BrowserAct services that use credits" />

## Workflow Built Credit Calculation

The following calculation applies only to Workflow Built Bots.

**Basic formula:** 1 executed step = 5 credits.

Standard actions include:

* Navigate to page
* Click element
* Input text
* Extract data
* Wait
* Go back
* Scroll

Special actions are calculated as follows:

* Loop: loop count x 5
* Loop List: item count x 5
* Scroll to element: scroll count x 5

## Credit Deduction Priority

Credits are used in the following order:

1. **Monthly Credits:** Subscription or AppSumo credits valid for the current monthly cycle.
2. **Existing permanent balance:** Used afterward when a permanent balance is shown on the account.

Credit Packs are not permanent credits. They expire at the next monthly credit reset.

## Payment Methods

BrowserAct accepts **PayPal** and supported **credit or debit cards processed through Stripe**.

## Request an Invoice

1. Create a support ticket in the [BrowserAct Discord community](https://discord.com/invite/UpnCKd7GaU), or email [support@browseract.com](mailto:support@browseract.com).
2. Share the order information needed to identify the purchase.
3. BrowserAct Support will verify the order and issue the invoice.

Do not include full payment-card details, passwords, or other sensitive account information.

## Infrastructure Charges

### Static Proxy

Static Proxies are charged in credits per proxy per month. The exact price depends on the selected location and proxy tier. Review the displayed price before confirming the purchase.

### Dynamic Proxy

Dynamic Proxy traffic is charged at **5,000 credits per GB**. Total usage depends on the bandwidth consumed by your Tasks.

### Local Fingerprint Browser

Creating a local fingerprint browser costs **100 credits per browser**.

Each creation is charged separately. If you delete a browser and create a new one, the new browser costs another 100 credits. Deleting a browser does not refund its creation charge.

See the [BrowserAct Pricing page](https://www.browseract.com/pricing) for current public pricing information.

## Earn Bonus Credits

* **2,000 credits for an approved G2 review:** After G2 approves the review, send the approval screenshot to BrowserAct Support for verification.
* **New account registration reward:** Eligible new users may receive bonus credits. The amount is subject to change; review the offer shown during registration or in the current promotion.
* **500 credits for starring the BrowserAct GitHub repository:** Star the official repository and complete the current reward-verification process.

Rewards are subject to account eligibility and verification.


# Choose a Plan
Source: https://docs.browseract.com/account-billing/billing/choose-plan

Compare BrowserAct plans, billing cycles, monthly credits, and included account limits.

Use the Plan page to compare BrowserAct subscriptions and choose the billing cycle and account limits that fit your usage.

## Open the Plan Page

1. Open `Plan & Billing` from the BrowserAct dashboard.
2. Select the `Plan` tab.

<img alt="Compare BrowserAct plans and billing cycles" />

## Review Your Credit Balance

The summary at the top can show:

* **Permanent Credits:** Credits that do not follow the monthly subscription reset when this balance is available on the account
* **Monthly Allotment:** Remaining credits from the current monthly allocation and the plan's monthly credit allowance

Credit Packs are not permanent credits. They expire at the next monthly credit reset.

## Choose a Billing Cycle

Use the `Monthly` and `Yearly` control to compare the available billing cycles.

* Monthly plans renew each month.
* Yearly plans are billed annually, while plan credits are allocated on a monthly cycle.
* Discounts, prices, and available plans can change. Review the values shown before purchase.

## Compare Plans

Each plan card shows its current price, monthly credits, and included limits. Depending on the plan, these can include:

* Concurrent Tasks
* MCP Servers
* Static Proxy allowance
* Included local fingerprint browsers
* Access to additional Credit Packs

Use the arrows beside the plan list to view additional plans when they do not fit on the screen.

## Buy Additional Credits

Eligible subscribed users and Lifetime Deal holders can select `Credit Packs` when the current monthly allocation is insufficient.

Credit Packs expire at the next monthly credit reset. Review the displayed expiration date before confirming a purchase.

## Upgrade Your Plan

### Upgrade Immediately

An immediate upgrade is available when more than 48 hours remain in the current monthly credit cycle.

* The upgraded plan benefits take effect immediately.
* You pay the displayed price difference between the current and upgraded plans.
* The difference in monthly credits is added to the current cycle.
* The original monthly credit reset date does not change.

### Upgrade at the Next Cycle

Choose a next-cycle upgrade when the new plan should start on the next monthly reset date.

* The current plan remains active until the current cycle ends.
* The full price of the new plan is charged when the upgrade is scheduled.
* The new plan and its monthly credits activate on the next billing date.

When fewer than 48 hours remain in the current cycle, this may be the only available upgrade option.

### Switch from Monthly to Yearly

Directly converting an active monthly subscription to a yearly subscription is not currently supported.

1. Open `Plan & Billing` and select `Subscription`.
2. Cancel the current monthly subscription.
3. Return to `Plan` and purchase the yearly plan.
4. Review the displayed activation date before confirming the purchase.

The yearly plan is scheduled to start at the beginning of the next billing cycle.

Before confirming any upgrade, review the amount charged, credits added, effective date, and next billing date shown in the product.


# Credit Packs
Source: https://docs.browseract.com/account-billing/billing/credit-packs

Add credits without changing your current BrowserAct plan.

## Eligibility

Credit Packs are supplementary credits available to:

* Users with an active monthly or yearly subscription
* Lifetime Deal holders

Credit Packs are not available on the Free Plan.

## Expiration and Reset Policy

Credit Pack credits are tied to the current monthly credit cycle. They expire at the next monthly credit reset and do not roll over.

This rule also applies to yearly subscriptions: the pack expires on the next monthly credit reset date, not at the end of the yearly subscription.

### Example

If the monthly credit cycle resets on January 15:

* A pack purchased on January 1 is available until January 15.
* A pack purchased on January 14 expires at the same reset on January 15.

## Purchase Confirmation

Before completing the purchase, review the confirmation dialog. It shows the expiration date of the credits being purchased.

## Refund Policy

Credit Pack purchases are final and non-refundable, including credits that remain unused when the monthly cycle resets.


# Manage Subscription
Source: https://docs.browseract.com/account-billing/billing/subscription-management

Understand monthly and yearly plans, monthly credit resets, and subscription cancellation.

## Choose a Billing Cycle

We offer two billing cycles to suit your needs:

* **Monthly Subscription:** Billed automatically each month.
* **Yearly Subscription:** Billed annually and currently includes a 20% discount compared with monthly billing.

> **Note:** All prices are billed in USD.

## Monthly Credit Allocation

To ensure a consistent experience, credits are distributed based on your **Monthly Billing Cycle**, regardless of whether you are on a Monthly or Yearly plan.

* **Distribution:** Credits are automatically added to your account at the start of each billing month.
* **No Roll-over Policy:** All unused credits **expire at the end of each billing cycle** and do not roll over to the next month.
* **Reset Logic:** Your credits reset on the same date each month.
  * **Example:** If you subscribed on **Jan 15th**, your current cycle ends on **Feb 14th at 23:59:59 (UTC)**. Your new credits will be issued, and the previous balance will reset, on **Feb 15th at 00:00:00 (UTC)**.

## Review Your Subscription

1. Open `Plan & Billing` from the BrowserAct dashboard.
2. Select the `Subscription` tab.

<img alt="Review the current BrowserAct subscription" />

The subscription record can show:

* **ID:** Subscription identifier
* **Status:** Current subscription state, such as active or canceled
* **Plan Details:** Plan name and billing cycle
* **Start Date:** When the subscription started
* **Next Billing Date:** The next scheduled renewal date when applicable
* **Amount:** Subscription amount
* **Actions:** Available management actions for the current subscription state

## Cancel Your Subscription

1. Open **Plan & Billing** from the BrowserAct dashboard.
2. Select the **Subscription** tab.
3. Locate the active subscription and choose the cancellation option.
4. Complete the confirmation steps shown in the account backend.

### What Happens After Cancellation?

* **Current Benefits:** You will retain access to all features and your remaining credits until the **end of your current billing cycle**.
* **Auto-Renewal:** Your subscription will not renew once the current period expires.
* **Next Charge:** After cancellation is confirmed, you will not be charged for the next billing cycle.
* **Account Status:** After the cycle ends, your account will automatically revert to the Free Tier.

## Refund Policy

Please note that all subscription payments are **non-refundable**. We recommend exploring our Free Plan or starting with a Monthly Plan to ensure our service meets your requirements before committing to a longer term.


# View Billing History
Source: https://docs.browseract.com/account-billing/billing/view-billing-history

Review BrowserAct transactions, payment status, payment method, and amount paid.

Use the Billing page to review transaction records associated with your BrowserAct account.

## Open Billing History

1. Open `Plan & Billing` from the BrowserAct dashboard.
2. Select the `Billing` tab.

<img alt="Review BrowserAct billing history" />

## Review a Transaction

Each transaction can include:

* **Transaction ID:** The identifier for the transaction
* **Status:** The current payment status
* **Type:** The transaction category
* **Payment Method:** How the transaction was completed
* **Date:** When the transaction was recorded
* **Description:** The plan, promotion, or purchase associated with it
* **Amount Paid:** The amount charged for the transaction
* **Actions:** Available transaction actions when supported

Keep the Transaction ID when contacting BrowserAct Support about a payment.

## Request an Invoice

Create a ticket in the [BrowserAct Discord community](https://discord.com/invite/UpnCKd7GaU), or email [support@browseract.com](mailto:support@browseract.com). Include the Transaction ID and the order information needed to identify the purchase.

Do not send full payment-card details, passwords, or other sensitive account information.


# View Credit Usage
Source: https://docs.browseract.com/account-billing/billing/view-credit-usage

Review BrowserAct credit consumption, usage trends, history, and low-balance alerts.

Use the Billing Dashboard to review how credits are consumed across BrowserAct services.

## Open the Billing Dashboard

1. Open `Plan & Billing` from the BrowserAct dashboard.
2. Select the `Dashboard` tab.

<img alt="BrowserAct credit usage dashboard" />

## Review Credit Consumption

The summary shows the current usage categories available for the account:

* **Total Credits Consumed:** Total usage and the remaining credit balance
* **Workflow Steps Executed:** Workflow Built steps and the related credit consumption
* **Dynamic Proxy Traffic:** Bandwidth used and the corresponding credits
* **Static Proxy:** Active Static Proxy usage when applicable
* **Local Browsers:** Active local fingerprint browsers and the related credits

## Filter the Usage Overview

Use the controls above the chart to:

* View the last 7, 30, or 90 days
* Select a custom date range
* Change the usage category shown in the chart

The chart compares activity volume with the credits consumed during the selected period.

## Review Usage History

Use `Usage History` to inspect individual credit consumption records.

<img alt="Review individual credit consumption records in Usage History" />

Each record can show:

* **Type:** The activity that consumed credits, such as Bot Build or Bot Run
* **Task:** The request summary, Task name, and Task ID
* **Credits Used:** Credits deducted by the activity
* **Started At:** When execution started
* **Ended At:** When execution finished
* **Created At:** When the Task was created

Filter the records by usage type, date range, or Task name and ID.

## Set a Low-Balance Alert

Turn on `Low Credit Balance Alert` when you want BrowserAct to notify you after the balance falls below a specified threshold.

<img alt="Configure a low credit balance alert" />

1. Enable the alert.
2. Enter the credit threshold.
3. Choose whether to notify every time the threshold is breached or once per day.

Review the current interface for the available delivery channel and alert status.


# Overview
Source: https://docs.browseract.com/account-billing/index



Use this section to manage personal account options, plans and credits, notification preferences, redemption codes, and affiliate access.

## Account

* Account Settings
* Redeem Code
* Affiliate
* Task Failure Alert

BrowserAct Cloud currently does not include team, member, role, or workspace administration in this section.

## Billing

* Billing and Credits
* Credit Usage
* Choose a Plan
* Billing History
* Credit Packages
* Subscriptions

For help resources and contact channels, open the separate **Support** section.


# Anti-detection & Blocking
Source: https://docs.browseract.com/agent-cli/anti-detection-blocking

Use environment, execution, and human handoff layers to handle anti-bot blocking.

Browser-act gives agents a practical escalation path for sites that block basic fetchers or standard browser automation.

<div>
  ```mermaid theme={null}
  flowchart TD
    Env["Environment"] --> Exec["Execution"]
    Exec --> Human["Human handoff"]
  ```
</div>

## Three-layer strategy

| Layer | Purpose | Key capabilities |
| - | - | - |
| Environment | Prevent challenges from appearing | stealth fingerprints, TLS rotation, proxy switching, privacy mode |
| Execution | Solve challenges after they appear | `solve-captcha`, `stealth-extract` |
| Human | Resolve cases automation cannot handle | `remote-assist` |

## Environment layer

The stealth browser is designed to look like a normal browser session instead of a script.

| Capability | What it does |
| - | - |
| Fingerprint masking | Keeps Canvas, WebGL, fonts, plugins, and related signals consistent |
| Navigator normalization | Normalizes `webdriver`, `chrome.runtime`, plugin arrays, and related browser properties |
| TLS signature rotation | Matches realistic browser TLS signatures |
| Headless concealment | Keeps headless mode from exposing common automation signals |
| Proxy system | Supports hosted dynamic proxies or your own static proxy |
| Privacy mode | Starts each session with a fresh fingerprint and empty profile |

### Dynamic proxy

```bash theme={null}
browser-act browser create \
  --type stealth \
  --name "jp-research" \
  --desc "Research browser using Japan dynamic proxy" \
  --dynamic-proxy JP
```

List available regions:

```bash theme={null}
browser-act browser regions
```

### Custom proxy

```bash theme={null}
browser-act browser create \
  --type stealth \
  --name "custom-proxy" \
  --desc "Stealth browser with a fixed custom proxy" \
  --custom-proxy socks5://user:pass@host:port
```

Custom proxies support HTTP and SOCKS5. You own the proxy quality, identity, and rotation strategy.

| Proxy option | Best for | Operational note |
| - | - | - |
| Dynamic proxy | Regional rotation and one-off collection | Browser-act rotates hosted IPs by region |
| Custom proxy | Stable identity and bring-your-own infrastructure | You manage proxy quality and reputation |

### Privacy mode

Use privacy mode when each session should start clean:

```bash theme={null}
browser-act browser create \
  --type stealth \
  --name "ephemeral" \
  --desc "One-time collection jobs" \
  --private true
```

> \[!TIP]
> Use privacy mode for one-off scraping, avoiding fingerprint buildup, and separating account identities. The trade-off is that login state is not preserved.

## Execution layer

### `stealth-extract`

Use `stealth-extract` when the task is read-only:

```bash theme={null}
browser-act stealth-extract https://example.com
```

It opens a stealth browser, renders the page, returns Markdown or HTML, and closes the browser.

```bash theme={null}
# Return HTML
browser-act stealth-extract https://example.com --content-type html

# Use a regional dynamic proxy
browser-act stealth-extract https://example.com --dynamic-proxy US

# Use a custom proxy
browser-act stealth-extract https://example.com --custom-proxy socks5://user:pass@host:port

# Save the result
browser-act stealth-extract https://example.com --output ./result.md
```

Use `stealth-extract` for reading. Use a browser session when you need interaction.

### `solve-captcha`

Use `solve-captcha` when a session reaches a supported CAPTCHA challenge:

```bash theme={null}
browser-act --session s1 solve-captcha
```

A successful result returns `solved=True`.

### Escalation flow

<div>
  ```mermaid theme={null}
  flowchart TD
    Blocked["Challenge"] --> Captcha["CAPTCHA"]
    Captcha --> Debug["Headed mode"]
    Debug --> Handoff["Remote assist"]
  ```
</div>

## Human layer

When automation cannot move forward, `remote-assist` creates a live URL. A human can open the link on any device, complete the challenge, and let the agent continue in the same session.

See [Remote Assist](/agent-cli/remote-assist).

## Recommended escalation

1. Start with `chrome` or `chrome-direct` for ordinary logged-in work.
2. Move to `stealth` with a proxy when blocking appears.
3. Use `solve-captcha` if a supported CAPTCHA appears.
4. Use `remote-assist` when human judgment, 2FA, hardware tokens, or unsupported challenges are required.

## Compared with basic tools

| Capability | curl / WebFetch | Standard Puppeteer / Playwright | Browser-act |
| - | - | - | - |
| JavaScript rendering | No | Yes | Yes |
| Anti-bot handling | No | Limited | Yes |
| CAPTCHA solving | No | No | Yes, when supported |
| Human takeover | No | Manual setup required | Built in with `remote-assist` |
| Stealth headless | Not applicable | Often detectable | Supported |

## Learn more

<Columns>
  <Card title="Better Headless Browser" icon="eye-off" href="/agent-cli/better-headless-browser">
    Run silently while keeping stealth and handoff available.
  </Card>

  <Card title="Browser Modes" icon="panel-top" href="/agent-cli/browser-modes">
    Choose the right browser identity for the job.
  </Card>

  <Card title="Skill Forge" icon="hammer" href="/agent-cli/skill-forge">
    Turn site-specific knowledge into a reusable skill.
  </Card>
</Columns>


# Better Headless Browser
Source: https://docs.browseract.com/agent-cli/better-headless-browser

Run browser automation headlessly without losing stealth or human handoff.

Browser-act runs headlessly by default so agents can work without interrupting the user's desktop. Headed mode is still available for local debugging and demos.

## Default headless mode

Headless mode is the default because it is quiet, resource-efficient, and suitable for background agent work.

Use headed mode only when the user needs to watch or debug the browser:

```bash theme={null}
browser-act --session debug browser open <browser_id> https://example.com --headed
```

## Stealth headless mode

Standard headless browsers are often detected through signals such as:

* `navigator.webdriver`
* missing plugins
* inconsistent Canvas or WebGL signatures
* suspicious browser properties

Browser-act stealth browsers keep fingerprint masking and headless concealment active together. The goal is to keep background automation quiet without exposing the common signs of headless automation.

## Human handoff without switching modes

Remote assist works even when the browser is headless:

```bash theme={null}
browser-act --session my-task remote-assist --objective "Complete 2FA verification"
```

The CLI returns a live URL. A human opens it in any browser, completes the step, and the agent continues in the same session.

## Mode comparison

<Columns>
  <Card title="Default headless" icon="eye-off">
    Best for background automation and routine tasks. The user does not watch the browser unless remote assist is used.
  </Card>

  <Card title="Headed mode" icon="monitor">
    Best for visual debugging, demos, and local manual steps. It interrupts the desktop and uses more resources.
  </Card>

  <Card title="Headless plus remote assist" icon="globe">
    Best for server work, 2FA, complex CAPTCHA, and human judgment. It requires sharing a temporary handoff link.
  </Card>
</Columns>

## When to use headed mode

> \[!TIP]
> Keep routine agent work headless. Use `--headed` only when local visual inspection is part of the task.

Use `--headed` when:

* a user wants to observe the browser locally
* visual debugging is needed
* a site behaves differently in visible mode
* you are preparing a demo

For most agent tasks, keep the browser headless and use remote assist only when needed.

## Learn more

<Columns>
  <Card title="Remote Assist" icon="radio" href="/agent-cli/remote-assist">
    Let a person take over from any device.
  </Card>

  <Card title="Anti-detection & Blocking" icon="shield-check" href="/agent-cli/anti-detection-blocking">
    Understand the blocking escalation path.
  </Card>

  <Card title="Browser Modes" icon="panel-top" href="/agent-cli/browser-modes">
    Pick the correct browser type.
  </Card>
</Columns>


# Browser Modes
Source: https://docs.browseract.com/agent-cli/browser-modes

Choose between chrome, chrome-direct, and stealth browsers for different automation jobs.

Browser-act uses browser types to represent different identity and runtime needs.

## Quick mode picker

Use the browser mode that matches the identity requirement of the task.

<div>
  ```mermaid theme={null}
  flowchart TD
    Start["Task need"] --> Login["Local login?"]
    Login -->|Yes| Chrome["chrome"]
    Login -->|No| Live["Live Chrome?"]
    Live -->|Yes| Direct["chrome-direct"]
    Live -->|No| Fresh["Fresh identity?"]
    Fresh -->|Yes| Privacy["stealth private"]
    Fresh -->|No| Fixed["Stable identity?"]
    Fixed -->|Yes| StealthFixed["stealth fixed"]
    Fixed -->|No| ChromeNew["chrome"]
  ```
</div>

| Mode | Best for | Key properties |
| - | - | - |
| `chrome` | Reusing local login state in an isolated browser | Profile import, isolated storage, repeatable automation |
| `chrome-direct` | Controlling the user's current Chrome | Existing extensions, SSO, certificates, and live cookies |
| `stealth` privacy mode | High-anonymity public data collection | Fresh fingerprint and empty profile per session |
| `stealth` fixed identity | Multi-account work | Stable fingerprint and fixed proxy per browser |

## `chrome`: reuse local login state

`chrome` browsers run in Browser-act-managed Chromium instances. They can import state from a local Chrome profile while staying isolated from the user's daily browser after import.

### Profile import

List local profiles:

```bash theme={null}
browser-act browser list-profiles
```

Create a browser from a discovered profile:

```bash theme={null}
browser-act browser create \
  --type chrome \
  --name "work-account" \
  --desc "Logged-in work account for reporting" \
  --source-profile <profile_id>
```

Import state into an existing browser:

```bash theme={null}
browser-act browser import-profile <browser_id> <profile_id>
```

If Chrome must be restarted during import:

```bash theme={null}
browser-act browser import-profile <browser_id> <profile_id> --allow-restart-chrome
```

> \[!WARNING]
> Profile import is a snapshot. Later changes in the source Chrome profile are not automatically synchronized.

### What profile import includes

| Included | Not included |
| - | - |
| Cookies | Browsing history |
| Local storage | Bookmarks |
| IndexedDB | Extensions |
| Session storage | Cached files |
| Relevant authentication state | Saved passwords |

Profile import is useful when a site requires an existing login but the agent should operate in an isolated browser.

## `chrome-direct`: control current Chrome

`chrome-direct` controls the user's current Chrome instance through CDP. It is useful when automation depends on local extensions, hardware-backed SSO, certificates, or state that cannot be copied safely.

Trade-offs:

* only one `chrome-direct` browser is allowed
* it operates on the live user browser
* it is not intended for headed mode switching
* it is best for short tasks that need the exact local Chrome environment

## Profile import vs. CDP direct

| Factor | `chrome` profile import | `chrome-direct` |
| - | - | - |
| Isolation | Separate managed browser | Live user Chrome |
| Extensions and certificates | Not copied | Available |
| Long-running tasks | Better fit | Use carefully |
| User browser availability | Independent after import | Uses the active browser |
| Quota | Up to 20 `chrome` browsers | One direct browser |

## `stealth`: privacy mode

Privacy mode starts each session with a fresh fingerprint and empty profile:

```bash theme={null}
browser-act browser create \
  --type stealth \
  --name "public-scrape" \
  --desc "Fresh identity for public data extraction" \
  --dynamic-proxy US \
  --private true
```

Use it for protected public data, one-off collection, and tasks where persistent identity is a liability.

Trade-offs:

* no login state is preserved
* an API key is required
* each session behaves like a new identity

## `stealth`: fixed identity

Fixed-identity stealth browsers keep a stable fingerprint and proxy:

```bash theme={null}
browser-act browser create \
  --type stealth \
  --name "account-a" \
  --desc "Fixed identity for account A" \
  --custom-proxy socks5://user:pass@host:port \
  --private false
```

Use this for multi-account work where each account needs a consistent browser identity.

> \[!NOTE]
> Hosted static IP support may depend on account configuration and availability. Use your own fixed proxy when a stable identity is required.

## Choose by scenario

<Columns>
  <Card title="Logged-in work" icon="key-round">
    Use `chrome` with profile import when the site needs reusable local login state.
  </Card>

  <Card title="Live local Chrome" icon="chrome">
    Use `chrome-direct` when the task depends on extensions, certificates, hardware SSO, or live cookies.
  </Card>

  <Card title="Protected public pages" icon="shield">
    Use `stealth` privacy mode or `stealth-extract` when there is no login and a fresh identity is safer.
  </Card>

  <Card title="Multiple accounts" icon="users">
    Use `stealth` fixed identity with separate proxies when each account needs a stable browser identity.
  </Card>
</Columns>

## Browser fields

| Field | Meaning |
| - | - |
| `id` | Browser identifier used in commands |
| `name` | Human-readable browser name |
| `type` | `chrome`, `chrome-direct`, or `stealth` |
| `desc` | Semantic description used by agents to choose a browser |
| `dynamic_proxy` | Hosted regional proxy setting for stealth browsers |
| `custom_proxy` | User-provided proxy URL |
| `private` | Whether sessions start with a clean profile |
| `confirm_before_use` | Whether the agent should ask before opening the browser |

## Learn more

<Columns>
  <Card title="Anti-detection & Blocking" icon="shield-check" href="/agent-cli/anti-detection-blocking">
    Understand stealth mode, proxies, CAPTCHA handling, and human handoff.
  </Card>

  <Card title="Concurrency & Isolation" icon="split" href="/agent-cli/concurrency-isolation">
    Run multiple browsers and sessions without leaking state between tasks.
  </Card>

  <Card title="Designed for Agents" icon="brain-circuit" href="/agent-cli/designed-for-agents">
    Learn how agents choose browsers by semantic `desc` fields.
  </Card>
</Columns>


# Command Reference
Source: https://docs.browseract.com/agent-cli/command-reference

Complete index of Browser-act CLI commands.

This page is a command index. Use the feature chapters for context, examples, and decision rules.

## Global options

> \[!NOTE]
> Global flags can be combined with command groups. Use `--session <name>` for browser interaction commands, `--format text|json` for output, `--no-auto-dialog` when dialogs should not be handled automatically, and `--version` to check the installed CLI.

| Option | Description |
| - | - |
| `--session <name>` | Session name for browser interaction commands |
| `--format text\|json` | Output format |
| `--no-auto-dialog` | Disable automatic dialog handling |
| `--version` | Show CLI version |

## Goal-based lookup

| I want to... | Use | Read more |
| - | - | - |
| Extract protected page content | `stealth-extract` | [Anti-detection & Blocking](/agent-cli/anti-detection-blocking) |
| Create a stealth browser | `browser create --type stealth ...` | [Browser Modes](/agent-cli/browser-modes) |
| Open a page and interact | `browser open` -> `state` -> `click` / `input` | [Quick Start](/agent-cli/quick-start) |
| Find API calls behind the UI | `network requests` -> `network request <request_id>` | [Designed for Agents](/agent-cli/designed-for-agents) |
| Handle CAPTCHA | `captcha-aid`, `solve-captcha`, `remote-assist` | [Anti-detection & Blocking](/agent-cli/anti-detection-blocking) |
| Let a human take over | `remote-assist --objective "..."` | [Remote Assist](/agent-cli/remote-assist) |
| Run multiple accounts | separate browsers and named sessions | [Concurrency & Isolation](/agent-cli/concurrency-isolation) |
| Reuse local login state | `browser import-profile` | [Browser Modes](/agent-cli/browser-modes) |

## Command groups

<Columns>
  <Card title="Browser interaction" icon="mouse-pointer-click" href="#browser-interaction-commands">
    Navigate pages, read state, click, type, extract, wait, capture network data, and manage tabs.
  </Card>

  <Card title="Browser management" icon="panel-top" href="#browser-management-commands">
    List, create, update, delete, open, and import browser profiles.
  </Card>

  <Card title="Sessions" icon="split" href="#session-management">
    List and close task workspaces.
  </Card>

  <Card title="Stealth extraction" icon="shield-check" href="#stealth-extraction">
    Extract protected content without opening a named session.
  </Card>

  <Card title="Authentication" icon="key-round" href="#authentication">
    Log in, poll device auth, set API keys, or clear credentials.
  </Card>

  <Card title="Skill and system" icon="layers" href="#skill-and-system">
    Load runtime-aware instructions, send feedback, and report logs.
  </Card>
</Columns>

## Browser interaction commands

These commands require `--session <name>`.

### Navigation

```text theme={null}
navigate <url> [--new-tab]
back
forward
reload
```

### Page state

```text theme={null}
state
screenshot [path] [--full]
```

`state` uses indexed markers:

* `[N]`: element index for commands such as `click N` or `input N "text"`
* `*[N]`: element is new or changed since the previous `state` call

### Interaction

```text theme={null}
click <index>
hover <index>
input <index> <text>
select <index> <option>
type <text>
keys <key_combo>
scroll up|down [--amount]
scrollintoview --selector <css>
upload <index> <path>
```

### Data extraction

```text theme={null}
get title
get html [--selector]
get text <index>
get value <index>
get markdown
```

### JavaScript

```text theme={null}
eval <js> [--stdin]
```

Use `eval` for complex extraction, page-local calculations, or fallback operations that are awkward through indexed interaction.

### Waiting

```text theme={null}
wait stable [--timeout]
wait selector <index> --state visible|hidden|attached|detached [--timeout]
wait selector --selector <css> --state visible|hidden|attached|detached [--timeout]
```

### Network

```text theme={null}
network requests [--filter] [--type] [--method] [--status] [--clear]
network request <request_id>
network clear
network offline on|off
network har start
network har stop [path]
```

Use network capture to inspect XHR requests, find API endpoints, debug authentication, or export HAR files.

### Tabs and dialogs

```text theme={null}
tab list
tab switch <tab_id>
tab close [tab_id]
dialog accept [text]
dialog dismiss
dialog status
```

### Cookies

```text theme={null}
cookies get [--url]
cookies set <name> <value> [--domain] [--path] [--secure] [--http-only]
cookies clear [--url]
cookies export <file>
cookies import <file>
```

### CAPTCHA and handoff

```text theme={null}
captcha-aid
solve-captcha
remote-assist [--objective]
```

| Command | Purpose |
| - | - |
| `captcha-aid` | Assist with CAPTCHA on the current page |
| `solve-captcha` | Try automatic CAPTCHA solving on the current page |
| `remote-assist` | Generate a live URL so a human can operate the browser |

## Browser management commands

These commands do not require a session unless noted by the command behavior.

```text theme={null}
browser list
browser open <id_or_url> [url_arg] [--headed] [--private] [--allow-restart-chrome]
browser create --type <chrome|chrome-direct|stealth> --name <name> --desc <description> [options]
browser update <browser_id> [options]
browser delete <browser_id>
browser regions
browser list-profiles
browser import-profile <browser_id> <profile_id> [--allow-restart-chrome]
```

### `browser create` options

```bash theme={null}
browser-act browser create \
  --type chrome|chrome-direct|stealth \
  --name "my-browser" \
  --desc "Purpose description" \
  --source-profile <profile_id> \
  --dynamic-proxy <region> \
  --custom-proxy <url> \
  --private true|false \
  --confirm-before-use
```

Option notes:

* `--source-profile` applies to `chrome` browsers.
* `--dynamic-proxy`, `--custom-proxy`, and `--private` apply to `stealth` browsers.
* `--confirm-before-use` marks a browser as sensitive so the agent should ask before opening it.

### `browser update` options

```bash theme={null}
browser-act browser update <browser_id> \
  --name "New name" \
  --desc "Replace the description" \
  --desc-append "Append to the description" \
  --dynamic-proxy <region> \
  --custom-proxy <url> \
  --no-proxy \
  --private true|false \
  --confirm-before-use|--no-confirm-before-use
```

## Session management

```text theme={null}
session list
session close [name]
```

## Stealth extraction

`stealth-extract` is independent. It does not require a session.

```bash theme={null}
browser-act stealth-extract <url>
browser-act stealth-extract <url> --content-type html|markdown
browser-act stealth-extract <url> --dynamic-proxy <region>
browser-act stealth-extract <url> --custom-proxy <proxy_url>
browser-act stealth-extract <url> --timeout 60
browser-act stealth-extract <url> --output ./result.md
```

## Authentication

```text theme={null}
auth login
auth poll
auth set <api_key>
auth clear
```

## Skill and system

```text theme={null}
get-skills core --skill-version <version>
get-skills advanced
get-skills main
report-log
feedback <message>
```

## Learn more

<Columns>
  <Card title="Designed for Agents" icon="brain-circuit" href="/agent-cli/designed-for-agents">
    Learn why the command model is optimized for agents.
  </Card>

  <Card title="Quick Start" icon="rocket" href="/agent-cli/quick-start">
    Combine commands into the first working browser loop.
  </Card>
</Columns>


# Concurrency & Isolation
Source: https://docs.browseract.com/agent-cli/concurrency-isolation

Understand how browsers and sessions let agents run parallel work without state leaks.

Browser-act separates **identity** from **work**:

* A **browser** is an identity: cookies, profile, fingerprint, proxy, and description.
* A **session** is a workspace: one task's current page, tabs, state, and command flow.

This model lets agents run multiple tasks without mixing state.

## Concurrency models

<div>
  ```mermaid theme={null}
  flowchart TD
    Task["Agent work"] --> Cross["Separate browsers"]
    Task --> Shared["Shared browser"]
    Task --> Private["Private sessions"]
  ```
</div>

| Model | Isolation level | Shared state | Best for |
| - | - | - | - |
| Cross-browser parallelism | Browser identity | Nothing by default | Multiple accounts, regions, or identities |
| Multiple sessions on one browser | Session workspace | Cookies and login state | Parallel tasks on the same account |
| Stealth privacy sessions | Fresh profile per session | Nothing persistent | One-off public data collection |

## Cross-browser parallelism

Each browser has independent cookies, fingerprints, and proxy settings.

```bash theme={null}
browser-act --session account-a browser open <browser_a_id> https://example.com
browser-act --session account-b browser open <browser_b_id> https://example.com
```

Session names must be globally unique. Use names that describe the task and identity.

## Multiple sessions on one browser

Use multiple sessions when tasks should share the same login state but run independently:

```bash theme={null}
browser-act --session inbox-check browser open <browser_id> https://example.com/inbox
browser-act --session report-export browser open <browser_id> https://example.com/reports
```

Both sessions share the browser's cookies and profile, but navigation and current page state are separate.

## Privacy mode sessions

For stealth browsers with `--private true`, each session starts with a fresh fingerprint and empty profile:

```bash theme={null}
browser-act browser create \
  --type stealth \
  --name "private-runner" \
  --desc "Fresh identity for one-off collection" \
  --private true
```

This avoids residue between jobs. The trade-off is that login state is not kept.

## Session lifecycle

<div>
  ```mermaid theme={null}
  flowchart TD
    Open["Open"] --> State1["State"]
    State1 --> Act["Act"]
    Act --> State2["State again"]
    State2 --> Repeat{"More?"}
    Repeat -->|Yes| Act
    Repeat -->|No| Close["Close"]
  ```
</div>

Rules:

* A session belongs to the agent or task that created it.
* A session is tied to one browser.
* One browser can have multiple sessions.
* Session names must be unique.
* Idle sessions may be reclaimed automatically after a period of inactivity.

List and close sessions:

```bash theme={null}
browser-act session list
browser-act session close <session_name>
```

## Commands that do not need a session

These commands operate outside a browser workspace:

* `browser list`
* `browser create`
* `browser update`
* `browser delete`
* `browser regions`
* `browser list-profiles`
* `session list`
* `auth login`, `auth poll`, `auth set`, `auth clear`
* `get-skills`
* `report-log`
* `feedback`
* `stealth-extract`

## Best practices

> \[!TIP]
> Use descriptive session names such as `pricing-us`, `login-check`, or `report-export`. Close sessions when the task is complete.

<Columns>
  <Card title="Shared account work" icon="copy">
    Use multiple sessions when tasks should share one browser identity and login state.
  </Card>

  <Card title="Separate identities" icon="fingerprint">
    Use separate browsers when tasks need separate accounts, regions, cookies, or proxies.
  </Card>

  <Card title="One-off jobs" icon="shield">
    Use privacy mode for work that should leave no persistent profile state.
  </Card>

  <Card title="Readable ownership" icon="tag">
    Name sessions by task and identity so agents and humans can understand what each session is doing.
  </Card>
</Columns>

## Learn more

<Columns>
  <Card title="Browser Modes" icon="panel-top" href="/agent-cli/browser-modes">
    Choose the right browser identity before running parallel work.
  </Card>

  <Card title="Designed for Agents" icon="brain-circuit" href="/agent-cli/designed-for-agents">
    See how naming, selection, and safety rules help agents operate cleanly.
  </Card>

  <Card title="Command Reference" icon="terminal" href="/agent-cli/command-reference">
    Look up browser and session management commands.
  </Card>
</Columns>


# Designed for Agents
Source: https://docs.browseract.com/agent-cli/designed-for-agents

Learn how Browser-act uses compact state, indexed actions, semantic browser descriptions, and safety gates for AI agents.

Browser-act is built for models, not for humans writing browser scripts by hand. The interface is designed around one question: **how can an AI agent understand the browser state and choose the next safe action?**

## Compact state output

Agents do not need the full DOM or verbose JSON for every step. `state` returns a compact, indexed view:

```text theme={null}
url=https://example.com/login
title=Login

*[1]<div id=login-form />
  *[2]<input type=email placeholder=Email address />
  *[3]<input type=password placeholder=Password />
  *[4]<button id=submit />
    Sign In
```

The `*` marker highlights new or changed elements since the previous state call. This helps the agent focus on what changed.

| State field | How the agent uses it |
| - | - |
| `url` | Confirms the current page before taking action |
| `title` | Checks whether navigation reached the expected screen |
| `[N]` index | Provides the target for commands such as `click 4` or `input 2` |
| `*` marker | Points attention to elements that changed after the last action |

## Indexed interaction

Agents act by element index:

```bash theme={null}
browser-act --session s1 click 4
browser-act --session s1 input 2 "hello@example.com"
```

<Columns>
  <Card title="No selector guessing" icon="mouse-pointer-click">
    Agents do not need to generate XPath or CSS selectors for routine actions.
  </Card>

  <Card title="Same view, same actions" icon="list-ordered">
    The agent acts on the same indexed elements it sees in `state`.
  </Card>

  <Card title="Refresh after change" icon="refresh-cw">
    Calling `state` again refreshes indexes after navigation or page updates.
  </Card>
</Columns>

## Semantic browser descriptions

Each browser has a `desc` field. It tells the agent what the browser is for:

```text theme={null}
Logged-in shopping account for price monitoring.
```

<Columns>
  <Card title="Match tasks" icon="target">
    Use `desc` to match a new request to an existing browser.
  </Card>

  <Card title="Avoid duplicates" icon="copy-check">
    Reuse known browsers instead of creating new ones for the same job.
  </Card>

  <Card title="Improve over time" icon="pencil">
    Append useful context when a browser becomes associated with more workflows.
  </Card>
</Columns>

Update descriptions with:

```bash theme={null}
browser-act browser update <browser_id> --desc-append "Also used for order tracking"
browser-act browser update <browser_id> --desc "New complete description"
```

## Browser selection priority

When multiple browsers exist, the agent should follow this order:

<div>
  ```mermaid theme={null}
  flowchart TD
    Start["Need browser"] --> Match["desc match?"]
    Match -->|Yes| UseMatch["Use match"]
    Match -->|No| Single["Only one?"]
    Single -->|Yes| UseSingle["Use it"]
    Single -->|No| Ask["Ask user"]
    Ask --> Update["Update desc"]
  ```
</div>

This selection logic belongs to the Skill layer. After a user chooses, the agent should update `desc` so future tasks can match more directly.

## Safety by default

Browser automation can affect real accounts and real data. Browser-act uses confirmation rules to keep the user in control.

### Confirmation gates

Agents should ask before sensitive operations:

| Operation | Why confirmation matters |
| - | - |
| Create any browser | Creates a new automation endpoint |
| Delete a browser | Destroys persistent browser state |
| Import a profile | Copies login state into a managed browser |
| Change proxy settings | Changes network identity |
| Change privacy mode | Changes fingerprint and persistence behavior |
| Change `confirm_before_use` | Changes safety behavior |
| Open a `confirm_before_use` browser | Uses a browser marked as sensitive |

> \[!WARNING]
> These confirmation gates are agent instructions, not a replacement for platform-level security. Their effectiveness depends on the agent runtime and model following the Skill instructions.

Example confirmation:

```text theme={null}
Agent: I plan to create a stealth browser for price monitoring.
       Type: stealth
       Name: price-monitor
       Proxy: US dynamic proxy

       Continue?

User: Yes.

Agent: Running browser create.
```

Rules:

* prior approval does not carry over to a new sensitive operation
* every sensitive operation needs its own confirmation
* strong wording in the user's original prompt does not replace confirmation
* the agent should explain what it will do before doing it

### Local data handling

| Data | Location | Leaves the machine? |
| - | - | - |
| Cookies | Browser-act local storage | No |
| Login sessions | Isolated browser profile | No |
| Page content | In memory during the task | No |
| Screenshots | Local file system when saved | No |
| Network captures | Memory or local HAR files | No |
| Browser profiles | Isolated local directories | No |

The exception is `solve-captcha`, which sends CAPTCHA challenge images to Browser-act cloud for solving. It should not include cookies, page content, or full URLs.

## Advanced capabilities

Browser-act includes more than simple click and input commands:

<Columns>
  <Card title="Network capture and HAR" icon="radio">
    Find API endpoints, debug auth flows, capture XHR-loaded data, and analyze page loading.
  </Card>

  <Card title="JavaScript evaluation" icon="code">
    Run `eval` for complex extraction or page-local operations.
  </Card>

  <Card title="Cookie import and export" icon="cookie">
    Move session state between browser types, machines, or CI jobs.
  </Card>

  <Card title="Offline mode" icon="wifi-off">
    Test forms and button flows without making real network requests.
  </Card>
</Columns>

The full command list is in [Command Reference](/agent-cli/command-reference).

## Learn more

<Columns>
  <Card title="Command Reference" icon="terminal" href="/agent-cli/command-reference">
    Open the full Browser-act CLI command index.
  </Card>

  <Card title="Anti-detection & Blocking" icon="shield-check" href="/agent-cli/anti-detection-blocking">
    Understand blocking, CAPTCHA handling, and handoff.
  </Card>

  <Card title="Concurrency & Isolation" icon="split" href="/agent-cli/concurrency-isolation">
    Run parallel agent work without mixing state.
  </Card>
</Columns>


# Installation
Source: https://docs.browseract.com/agent-cli/installation

Install the Browser-act CLI, configure the entry Skill, and verify the runtime.

Install Browser-act in two parts:

1. The **Browser-act CLI**, which performs browser automation.
2. The **entry Skill**, which tells your AI agent when and how to call the CLI.

<Columns>
  <Card title="1. Add the entry Skill" icon="sparkles">
    Let your agent discover Browser-act and learn that `get-skills` must be loaded before browser work.
  </Card>

  <Card title="2. Verify the CLI" icon="terminal">
    Install `browser-act-cli`, check the version, and confirm the runtime can execute commands.
  </Card>
</Columns>

## Agent installation

For agents that support skills, the shortest path is to ask the agent to install Browser-act for you:

```text theme={null}
Install browser-act.
Skill URL: https://github.com/browser-act/skills/tree/main/browser-act
After installation, verify that the CLI is available.
```

The agent should install the CLI, add the Skill file to its skill directory, and run a basic availability check.

## Manual CLI installation

Install the CLI with `uv` and Python 3.12:

```bash theme={null}
uv tool install browser-act-cli --python 3.12
```

Verify the command:

```bash theme={null}
browser-act --version
```

## Optional: API key

> \[!NOTE]
> Browser-act can run basic Chrome and chrome-direct browser automation without an API key. An API key unlocks hosted capabilities: `stealth` browsers, `stealth-extract`, dynamic proxy rotation, and `solve-captcha`.

Start the login flow:

```bash theme={null}
browser-act auth login
browser-act auth poll
```

Or set a key directly:

```bash theme={null}
browser-act auth set <your_api_key>
```

## Upgrade

Upgrade the CLI with:

```bash theme={null}
uv tool upgrade browser-act-cli
```

> \[!TIP]
> The Skill layer can detect version mismatches between the installed Skill and the CLI. When that happens, `get-skills` returns upgrade guidance for the agent.

## Requirements

| Requirement | Notes |
| - | - |
| Python 3.12+ | Required by the CLI package |
| Chrome or Chromium | Required for `chrome` and `chrome-direct` browser types |
| API key | Required only for `stealth` browser features |

## Troubleshooting

### Command not found after installation

> \[!WARNING]
> If `browser-act` is not found after installation, make sure the `uv` tool directory is in your shell `PATH`.

```bash theme={null}
uv tool dir
```

Add the returned directory to `PATH`, then open a new terminal.

### Send diagnostics

Upload diagnostic logs:

```bash theme={null}
browser-act report-log
```

Send product feedback:

```bash theme={null}
browser-act feedback "Describe the issue or suggestion"
```

## What is next

<Columns>
  <Card title="Continue to Quick Start" icon="rocket" href="/agent-cli/quick-start">
    Run a content extraction or a browser session in about a minute.
  </Card>

  <Card title="Learn the Skill System" icon="layers" href="/agent-cli/skill-system">
    See how the entry Skill and `get-skills` keep agent instructions current.
  </Card>
</Columns>


# Introduction
Source: https://docs.browseract.com/agent-cli/introduction

Browser-act is an Agent CLI for browser automation.

Browser-act is a browser automation CLI built for AI agents. It helps agents open pages, read page state, click, type, extract data, manage sessions, bypass common blocking, and hand control to a human when automation gets stuck.

## Start here

<Columns>
  <Card title="Install" icon="download" href="/agent-cli/installation">
    Install the Browser-act CLI, add the entry Skill to your agent, and verify that the runtime is available.
  </Card>

  <Card title="Quick Start" icon="rocket" href="/agent-cli/quick-start">
    Run your first extraction or full browser automation loop with Browser-act.
  </Card>

  <Card title="Command Reference" icon="terminal" href="/agent-cli/command-reference">
    Look up browser, session, stealth, CAPTCHA, network, and system commands.
  </Card>
</Columns>

## Why Browser-act

AI agents need a browser that goes beyond standard automation tools.

<Columns>
  <Card title="Bypass blocking" icon="shield-check">
    Use stealth fingerprints, TLS rotation, proxies, CAPTCHA solving, and remote handoff when a site challenges automation.
  </Card>

  <Card title="Choose the right browser" icon="panel-top">
    Use local Chrome state, direct Chrome control, privacy-focused stealth sessions, or fixed-identity stealth browsers.
  </Card>

  <Card title="Run concurrent work" icon="split">
    Keep browsers, sessions, cookies, fingerprints, and proxies isolated so multiple tasks do not interfere with each other.
  </Card>

  <Card title="Work in model-friendly state" icon="braces">
    Read compact indexed state, act with commands such as `click 3`, and reuse browsers by semantic descriptions.
  </Card>
</Columns>

## Core capabilities

| Capability | What it helps with |
| - | - |
| Anti-detection and blocking | Reach pages that block basic fetchers or standard automation |
| Better headless mode | Run silently without giving up stealth or human handoff |
| Remote assist | Let a human complete 2FA, CAPTCHA, or judgment-heavy steps from any device |
| Browser modes | Pick between Chrome, chrome-direct, stealth privacy, and stealth fixed identity |
| Concurrency and isolation | Run many agents, tasks, accounts, and sessions without state leaks |
| Skill Forge | Turn a one-time site exploration into a reusable scraping skill |

## Compatibility

| Area | Support |
| - | - |
| Operating systems | Windows, macOS, Linux |
| Agent environments | Claude Code, Cursor, VS Code, OpenCode, OpenClaw, Codex, Gemini CLI, and other agents that can run shell commands and load skills |
| Runtime objects | browser, session, profile, stealth browser, network capture, HAR, cookies |


# Quick Start
Source: https://docs.browseract.com/agent-cli/quick-start

Get your first result in 60 seconds with extraction or a full browser session.

There are two fast paths:

* Use `stealth-extract` when you only need to read page content.
* Use a browser session when you need to click, type, log in, or inspect state between steps.

<Columns>
  <Card title="Path A: Extract content" icon="file-text" href="#path-a-extract-content">
    Use `stealth-extract` for JS-rendered pages, protected content, and one-off collection.
  </Card>

  <Card title="Path B: Automate a browser" icon="mouse-pointer-click" href="#path-b-automate-a-browser">
    Open a browser session, inspect page state, and interact with elements by index.
  </Card>
</Columns>

## Path A: extract content

Use this when basic fetchers cannot handle JavaScript rendering, anti-bot checks, or region restrictions:

```bash theme={null}
browser-act stealth-extract https://example.com
```

The command opens a stealth browser, waits for the page to render, returns content as Markdown, and closes the browser. You do not need to manage a browser or session.

Common options:

```bash theme={null}
# Return HTML instead of Markdown
browser-act stealth-extract https://example.com --content-type html

# Use a dynamic proxy for a specific region
browser-act stealth-extract https://example.com --dynamic-proxy JP

# Save the result to a file
browser-act stealth-extract https://example.com --output ./page.md
```

Use this path for protected content, batch collection, and information retrieval. See [Anti-detection & Blocking](/agent-cli/anti-detection-blocking).

## Path B: automate a browser

Use this path when the task requires interaction.

```bash theme={null}
# 1. List available browsers
browser-act browser list

# 2. Open a browser and start a named session
browser-act --session my-task browser open <browser_id> https://example.com

# 3. Read the current page state
browser-act --session my-task state

# 4. Interact with elements by index
browser-act --session my-task click 4
browser-act --session my-task input 2 "hello@example.com"

# 5. Close the session when finished
browser-act session close my-task
```

## The core loop

<div>
  ```mermaid theme={null}
  flowchart TD
    Open["Open"] --> State1["State"]
    State1 --> Act["Act"]
    Act --> State2["State again"]
    State2 --> Act
    State2 --> Close["Close"]
  ```
</div>

1. **Open** a page with `browser open`.
2. **Read state** to see the current URL, title, and indexed elements.
3. **Interact** with `click`, `input`, `select`, and related commands.
4. **Read state again** after the page changes.
5. Repeat until the task is complete.
6. **Close** the session.

## Understand `state`

`state` is the agent's view of the page. It returns compact text with indexed elements:

```text theme={null}
url=https://example.com/login
title=Login

*[1]<div id=login-form />
  *[2]<input type=email placeholder=Email address />
  *[3]<input type=password placeholder=Password />
  *[4]<button id=submit />
    Sign In
  *[5]<a />
    Forgot password?
```

Each `[N]` is an element index:

```bash theme={null}
browser-act --session login input 2 "user@example.com"
browser-act --session login input 3 "password123"
browser-act --session login click 4
```

Indexes can change after navigation, page updates, or DOM changes. Call `state` again before acting on a changed page.

## Chain commands carefully

> \[!TIP]
> Chain commands only when each step is independent. If the next action depends on page output, run `state` first and decide from the result.

Use `&&` for independent steps:

```bash theme={null}
browser-act --session s1 input 2 "user" && \
browser-act --session s1 input 3 "pass" && \
browser-act --session s1 click 4
```

Run commands separately when the next action depends on intermediate output, such as reading `state` before choosing what to click.

## Learn more

<Columns>
  <Card title="Browser Modes" icon="panel-top" href="/agent-cli/browser-modes">
    Pick Chrome, chrome-direct, stealth privacy, or stealth fixed identity.
  </Card>

  <Card title="Anti-detection & Blocking" icon="shield-check" href="/agent-cli/anti-detection-blocking">
    Use stealth, CAPTCHA solving, proxy options, and remote handoff.
  </Card>

  <Card title="Better Headless Browser" icon="eye-off" href="/agent-cli/better-headless-browser">
    Keep browser work headless while preserving stealth and handoff.
  </Card>

  <Card title="Concurrency & Isolation" icon="split" href="/agent-cli/concurrency-isolation">
    Separate browsers, sessions, accounts, and one-off jobs.
  </Card>

  <Card title="Command Reference" icon="terminal" href="/agent-cli/command-reference">
    Open the full CLI command index.
  </Card>

  <Card title="Skill Forge" icon="hammer" href="/agent-cli/skill-forge">
    Turn a successful exploration into a reusable scraping skill.
  </Card>
</Columns>


# Remote Assist
Source: https://docs.browseract.com/agent-cli/remote-assist

Generate a live URL so a human can take over a stuck browser session from any device.

Remote Assist lets an agent hand control to a person when automation reaches a step that needs human input.

## Hand off in one command

```bash theme={null}
browser-act --session my-task remote-assist --objective "Complete 2FA verification"
```

The `--objective` text tells the human what to complete. The CLI returns a live URL for the current session.

## Any-device takeover

<Columns>
  <Card title="Desktop" icon="monitor">
    Open the handoff link from a desktop browser.
  </Card>

  <Card title="Laptop" icon="laptop">
    Use a nearby laptop while the agent keeps the session alive.
  </Card>

  <Card title="Mobile" icon="smartphone">
    Complete 2FA or quick checks from a phone or tablet.
  </Card>

  <Card title="Remote host" icon="server">
    Take over from your own device while the agent runs elsewhere.
  </Card>
</Columns>

No headed browser, VNC, RDP, screen sharing, or extra client software is required.

## Typical scenarios

| Scenario | How Remote Assist helps |
| - | - |
| Two-factor authentication | User enters SMS, authenticator app, or email codes |
| Complex CAPTCHA | Person completes drag puzzles, behavior checks, or unsupported CAPTCHA types |
| Enterprise SSO | User handles hardware tokens, certificates, or local device checks |
| Human judgment | User chooses between options or approves a sensitive step |
| Collaboration | Teammate opens the link and completes the blocked step |

## Continue after handoff

After the human completes the task:

* the session does not restart
* cookies and browser state remain available
* the current page position is preserved
* the agent can continue with the next command

## Compared with standard approaches

| Need | Standard setup | Browser-act |
| - | - | - |
| Human intervention in headless mode | Switch to headed mode or attach a desktop | Generate a live URL |
| Same-machine access | Usually required | Not required |
| Extra software | Often VNC, RDP, or screen sharing | None |
| Cross-device support | Limited | Any modern browser |
| Resume automation | Often manual | Continue in the same session |

## Learn more

<Columns>
  <Card title="Better Headless Browser" icon="eye-off" href="/agent-cli/better-headless-browser">
    Understand how handoff works with headless sessions.
  </Card>

  <Card title="Anti-detection & Blocking" icon="shield-check" href="/agent-cli/anti-detection-blocking">
    Use automatic escalation before handoff when appropriate.
  </Card>

  <Card title="Designed for Agents" icon="bot" href="/agent-cli/designed-for-agents">
    Learn the safety and confirmation model.
  </Card>
</Columns>


# Skill Forge
Source: https://docs.browseract.com/agent-cli/skill-forge

Use Browser-act to generate reusable scraping skills after exploring a website once.

Skill Forge is an extension built on Browser-act CLI. It lets AI agents explore a website once, then generate a reusable skill for repeated extraction or automation.

## The problem

Without a reusable skill, an agent has to rediscover the same website every time:

* paths change between runs
* failure modes differ
* scaling is unreliable
* token usage grows with every call

Skill Forge separates **exploration** from **reuse**.

> \[!NOTE]
> Explore once. Generate a deployable skill package. Reuse the same stable path for hundreds or thousands of inputs.

## Installation

Skill Forge is separate from the Browser-act entry Skill. Install the entry Skill and CLI first.

Ask your agent:

```text theme={null}
Install browser-act-skill-forge.
Skill URL: https://github.com/browser-act/skills/tree/main/browser-act-skill-forge
After installation, verify that it is available.
```

Requirements:

* [Browser-act CLI installed](/agent-cli/installation)
* Browser-act entry Skill installed
* A task that can be described in natural language

## Four-step pipeline

<div>
  ```mermaid theme={null}
  flowchart LR
    Describe["Describe"] --> Explore["Explore"]
    Explore --> Generate["Generate"]
    Generate --> Test["Self-test"]
  ```
</div>

| Step | What happens |
| - | - |
| 01. Describe | Tell the agent what data or action you need |
| 02. Explore | The agent looks for an API-first path, then falls back to DOM automation if needed |
| 03. Generate | The agent creates a parameterized skill package |
| 04. Self-test | The generated skill is tested and repaired until it works |

### 01. Describe the task

Use natural language:

```text theme={null}
Extract job title, company, salary, and URL from LinkedIn jobs.
I will later run this for 300 keywords.
```

### 02. Explore API-first, DOM fallback

Skill Forge prefers stable paths:

| Priority | Strategy | Stability |
| - | - | - |
| 1 | API-first through network capture | More stable when backend contracts stay the same |
| 2 | DOM fallback through browser automation | Works when no useful API path is available |

### 03. Generate a parameterized skill

Business variables become CLI parameters instead of hard-coded values:

```bash theme={null}
job-search --keyword "designer" --location "Berlin" --limit 100
```

Typical output:

* `SKILL.md`
* executable script
* usage instructions
* self-test evidence

### 04. Self-test and repair

The generated skill should be tested end to end. When the target site changes, the agent can re-explore and update the skill instead of rediscovering the workflow on every run.

## Business value

<Columns>
  <Card title="For individual developers" icon="user">
    Pay the exploration cost once, reuse the generated path for many inputs, and re-explore only when the site changes.
  </Card>

  <Card title="For teams" icon="users">
    Move repeatable scraping work from one-off scripts toward generated, tested, reusable capabilities.
  </Card>
</Columns>

Traditional model:

```text theme={null}
request -> engineer writes scraper -> test -> deploy -> maintain
```

Skill Forge model:

```text theme={null}
request -> agent explores -> skill generated -> self-test -> deploy
```

The engineering work shifts from writing every scraper by hand to maintaining a system that lets agents generate reusable capabilities.

## Use cases

<Columns>
  <Card title="Batch data collection" icon="list">
    Run one pattern across many keywords, regions, or categories.
  </Card>

  <Card title="Cross-site price comparison" icon="scale">
    Generate skills for multiple sites and normalize output.
  </Card>

  <Card title="Periodic monitoring" icon="activity">
    Track price, inventory, or listing changes.
  </Card>

  <Card title="Internal processes" icon="briefcase-business">
    Wrap repeated browser operations into reusable skills.
  </Card>
</Columns>

## Entry Skill vs. Skill Forge

| Area | Browser-act entry Skill | Skill Forge |
| - | - | - |
| Role | Gives the agent Browser-act CLI capability | Generates reusable task-specific skills |
| Required | Yes | Optional |
| Usage | Agent operates the browser in real time | Agent explores once and reuses generated skill |
| Token cost | Paid during each live exploration | Concentrated during skill generation |

Browser-act gives agents the ability to act. Skill Forge helps agents turn a successful action path into a reusable skill.

## Learn more

<Columns>
  <Card title="Installation" icon="download" href="/agent-cli/installation">
    Install the base CLI and entry Skill before using Skill Forge.
  </Card>

  <Card title="Anti-detection & Blocking" icon="shield-check" href="/agent-cli/anti-detection-blocking">
    Use blocking tools during exploration when a site challenges automation.
  </Card>

  <Card title="Designed for Agents" icon="brain-circuit" href="/agent-cli/designed-for-agents">
    Use network capture and semantic descriptions effectively.
  </Card>
</Columns>


# Skill System
Source: https://docs.browseract.com/agent-cli/skill-system

Understand the two-layer entry Skill and get-skills runtime model.

Browser-act uses a two-layer Skill model:

1. The **entry Skill** makes the agent aware that Browser-act exists.
2. The **`get-skills` runtime** returns current environment state, command guidance, and dynamic instructions.

## Install the entry Skill

Ask your agent:

```text theme={null}
Install the browser-act Skill from:
https://github.com/browser-act/skills/tree/main/browser-act
```

After installation, the agent can recognize Browser-act tasks and call `get-skills` before using the CLI.

## Two layers

<div>
  ```mermaid theme={null}
  flowchart TD
    User["Browser task"] --> Entry["Entry Skill"]
    Entry --> Runtime["get-skills runtime"]
    Runtime --> State["Runtime state"]
    Runtime --> Rules["Safety rules"]
    Runtime --> Version["Version guidance"]
  ```
</div>

## Layer 1: entry Skill

The installed Skill file is intentionally small. It:

* triggers agent awareness
* contains activation language
* tells the agent to load runtime content through `get-skills`
* changes rarely

## Layer 2: `get-skills`

The first command for a Browser-act task should be:

```bash theme={null}
browser-act get-skills core --skill-version <version>
```

The output gives the agent:

* CLI and API key status
* available browsers and descriptions
* active sessions
* core command guidance
* dynamic instructions for the current environment

## Topics

<Columns>
  <Card title="core" icon="route">
    `get-skills core --skill-version <v>` returns the core workflow, commands, browser state, and safety rules for most tasks.
  </Card>

  <Card title="advanced" icon="settings">
    `get-skills advanced` returns proxy, profile import, privacy mode, and advanced browser setup guidance.
  </Card>

  <Card title="main" icon="refresh-cw">
    `get-skills main` returns the latest Skill content when a version mismatch is detected.
  </Card>
</Columns>

## Progressive loading

> \[!TIP]
> Most tasks only need `get-skills core`. Load advanced topics only when the task requires them. This keeps the agent context focused and reduces irrelevant instructions.

## Version compatibility

The `--skill-version` parameter lets the CLI detect mismatches:

```bash theme={null}
browser-act get-skills core --skill-version 2.0.2
```

When versions are incompatible, the output includes direct upgrade guidance:

<Columns>
  <Card title="CLI too old" icon="terminal">
    Run `uv tool upgrade browser-act-cli`.
  </Card>

  <Card title="Skill too old" icon="download">
    Run `browser-act get-skills main`.
  </Card>
</Columns>

## Dynamic instructions

`get-skills` adjusts guidance based on the current state:

| Situation | Instruction returned |
| - | - |
| Multiple browsers exist | Choose by `desc` match or ask the user |
| Active sessions exist | Respect session ownership and naming |
| API key is missing | Avoid stealth-only features or guide authentication |
| Sensitive browser is selected | Ask before opening a `confirm_before_use` browser |

## Agent workflow

<div>
  ```mermaid theme={null}
  flowchart TD
    Ask["User asks"] --> Activate["Skill activates"]
    Activate --> Load["Run get-skills"]
    Load --> Read["Read state"]
    Read --> Select["Select browser"]
    Select --> Confirm["Confirm if needed"]
    Confirm --> Run["Run commands"]
    Run --> Finish["Close session"]
  ```
</div>

## Agent compatibility

Browser-act can work with agents that can:

1. load Skill files
2. run shell commands
3. read text output

Known compatible environments include Claude Code, GitHub Copilot, Cursor, Windsurf, Gemini CLI, OpenCode, Codex, and similar agent runtimes.

## Learn more

<Columns>
  <Card title="Quick Start" icon="rocket" href="/agent-cli/quick-start">
    Run the first Browser-act automation loop.
  </Card>

  <Card title="Command Reference" icon="terminal" href="/agent-cli/command-reference">
    Open the full command index.
  </Card>

  <Card title="Skill Forge" icon="hammer" href="/agent-cli/skill-forge">
    Generate reusable task-specific skills.
  </Card>
</Columns>


# Browse Templates
Source: https://docs.browseract.com/bot-templates/browse-templates

Find a BrowserAct Bot Template for your target website and data needs.

Open the [BrowserAct Template Marketplace](https://www.browseract.com/template?co-from=bot-template-help-center) to find ready-to-run Bots.

## Choose a Template

1. Search for the website or task you want to automate.
2. Open a template to review its purpose, required inputs, expected output, approximate credit range, and supported Browser Settings.
3. Select `Quick Start` when the template already matches your scenario.
4. Select `Create Editable Duplicate` when you need to change its fields, logic, or target scenario.

Approximate credits are provided as a reference. Actual usage may vary by website, input size, browser settings, and runtime behavior.


# Create an Editable Duplicate
Source: https://docs.browseract.com/bot-templates/create-editable-duplicate

Create an independent Agent Built Bot from a BrowserAct Bot Template.

Use `Create Editable Duplicate` when a template is a useful starting point but you need to change its extraction fields, logic, or target scenario.

## Create the Duplicate

1. Open the [BrowserAct Template Marketplace](https://www.browseract.com/template?co-from=bot-template-help-center).
2. Select the template you want to customize.
3. Select `Create Editable Duplicate`.
4. Open the new Agent Built Bot from your `Bots` list and make the required changes.

<img alt="Create an editable duplicate from a Bot Template" />

The duplicate is an independent Agent Built Bot. Changes to your duplicate do not affect the official template, and later updates to the official template are not applied automatically to the duplicate.


# Bot Templates
Source: https://docs.browseract.com/bot-templates/introduction

Start faster with ready-to-run BrowserAct Bot Templates.

Bot Templates are ready-to-run Bots for common web data extraction and browser automation scenarios. Use a template as provided, return to it from your `Bots` list, or create an editable duplicate when you need to customize the Bot.

## What You Can Do

* Browse official templates in the BrowserAct Template Marketplace
* Enter your own runtime inputs and run a template immediately
* Review each run from the Bot's `History` tab or the account-level `Tasks` page
* Adjust supported browser and proxy settings
* Create an independent editable copy when you need to change fields, logic, or the target scenario

## Template Bots and Editable Duplicates

A template Bot keeps the official template structure read-only while allowing you to provide new inputs and maintain supported Browser Settings. `Create Editable Duplicate` creates a separate Agent Built Bot that you can modify independently.

Template Bots do not include the publisher's cookies, browser profiles, passwords, or API keys.

<Card title="Explore Bot Templates" icon="layout-template" href="https://www.browseract.com/template?co-from=bot-template-help-center">
  Open the BrowserAct Template Marketplace.
</Card>


# Manage Template Bots
Source: https://docs.browseract.com/bot-templates/manage-template-bots

Find, rerun, and review the template Bots in your BrowserAct account.

After you run a template, BrowserAct creates or reuses a template Bot in your account. You can return to it without reopening the Template Marketplace.

## Find Template Bots

1. Open `Bots`.
2. Select the `Template` filter.
3. Open the template Bot you want to manage.

<img alt="Find template Bots with the Template filter" />

From the template Bot, you can:

* Enter new runtime inputs and run it again
* Review previous Tasks from `History`
* Adjust supported browser and proxy settings from `Browser Settings`
* Create an editable duplicate when you need to change the Bot itself

The official template structure remains read-only. BrowserAct template updates preserve the existing template Bot's settings and History.


# Run a Template
Source: https://docs.browseract.com/bot-templates/run-a-template

Run a ready-made BrowserAct Bot Template and review its structured result.

Use a template when the existing scenario already matches what you want to extract or automate.

## Run the Template

1. Open the [BrowserAct Template Marketplace](https://www.browseract.com/template?co-from=bot-template-help-center).
2. Select the template you want to use.
3. Select `Quick Start`, or open the `Run Task` tab.
4. Enter the required inputs and select `Run`.
5. Review the structured result after the Task completes.

<img alt="Open Run Task or select Quick Start to run a Bot Template" />

Each run creates a Task record. You can review the result from the Bot's `History` tab or from the account-level `Tasks` page.

Running a template usually costs less than building a Bot from scratch because the Bot structure has already been prepared. Actual credit usage may vary by website, input size, browser settings, and runtime behavior.


# Template FAQ
Source: https://docs.browseract.com/bot-templates/template-faq

Answers to common questions about BrowserAct Bot Templates.

## Can I edit a template Bot?

You can change the input values for each run. To change the extraction fields, logic, or target scenario, use `Create Editable Duplicate` to create an independent editable Bot.

## Will template updates overwrite my Bot settings or History?

No. Official template updates preserve the existing template Bot's settings and History. A Bot created with `Create Editable Duplicate` is independent and does not automatically receive later template updates.

## Can I publish my own Agent Built Bot as a public template?

Not currently. Users cannot publish Agent Built Bots directly to the public Template Marketplace.

## Can I use template Bots with Make, n8n, Zapier, API, or MCP?

Yes. Official template Bots can be called through Make, n8n, Zapier, the BrowserAct API, or MCP. Follow the setup instructions in [Integrations](/integrations/integration-overview) for the connection method you want to use.

## Can I change browser mode or proxy settings for a template Bot?

Yes. Open the template Bot and use `Browser Settings` to adjust the supported browser and proxy configuration.


# Agent Built
Source: https://docs.browseract.com/bot/agent-built/agent-built



Agent Built creates a Bot from a natural-language data request. It is the simplest option when you know what data you need but do not want to build the browser steps manually.

## Step 1: Describe What You Need

On Home, start Agent Built in either of these ways:

* Select one of the configured prompt templates below the prompt box.
* Enter your own request directly in the prompt box.

<img alt="Choose a prompt template or enter your own request on Home" />

You can also select `Create`, then choose `Start building` under `Build with Agent`.

<img alt="Select Create and start building with Agent" />

For a clear request, include:

* **Website:** Where BrowserAct should start
* **Records:** What items or pages to collect
* **Conditions:** Keywords, categories, locations, filters, or date ranges
* **Fields:** The exact data to return
* **Limit:** How many results you need
* **Inputs:** Values you want to change in future runs

Example:

```text theme={null}
Go to the Amazon Best Sellers page and collect the top 20 products
from the Clothing, Shoes & Jewelry department. Return the rank,
product name, price, rating, review count, image URL, and product URL.
```

> **Tip:** Specific requests produce better Bots. Include the target page, record limit, conditions, and required fields.

### Choose Browser Mode and Proxy Region

Before submitting the request, select the browser mode and proxy region that fit the target website and task.

<img alt="Choose the browser mode and proxy region before building" />

Submit the request when it describes the result you expect.

### Optional Build Support

Agent Built includes optional tools that can provide more context or help you start faster:

* Start from an available prompt template and edit it for your target website.
* Upload supported files, such as PDF, DOCX, or XLSX, as context for the build.
* Preview or download validation data retained during the build when available.

Supported file formats, file limits, and validation-data availability depend on the current product configuration.

## Step 2: Let BrowserAct Build and Test the Bot

BrowserAct interprets the request, explores the live website, builds the extraction path, and tests the requested result.

After you submit the request, the Agent analyzes it and asks you to confirm the target before continuing. Review and confirm the target within 60 minutes.

If information is missing, BrowserAct may ask you to clarify the website, conditions, fields, or expected output. Reply in the same build conversation.

For supported login or verification steps during building, BrowserAct may provide a controlled assistance path. Complete it only for pages you are authorized to access.

## Step 3: Run the Bot and Get Results

When the build is complete, select `Run` at the bottom of the Build page. Review the resulting Task and structured records after the run finishes.

Verify source URLs and any missing fields before exporting or integrating the result.

To change the fields, inputs, pages, or navigation behavior later, see [Improve a Bot](../improve/improve-a-bot.md).


# Bot Introduction
Source: https://docs.browseract.com/bot/bot-introduction



A Bot is a reusable Cloud automation for a repeatable web data task.

Both Agent Built and Workflow Built create Bots. After construction, the automation is managed, identified, and run as a Bot.

## How Bots Work

Building defines and tests the Bot's extraction logic. Running uses a specific set of inputs to produce a structured result.

Each build, test, or run creates a separate Task. A Task records the operation and its available status, inputs, result, and usage information.

## Bot Inputs

Inputs are values that can change between runs, such as:

* URL
* Keyword
* Country or region
* Category
* Date range
* Record limit

Default values make a Bot easier to test, but users can replace them when running the Bot.

## Bot Outputs

Outputs are the structured fields returned by the Bot, such as product name, price, rating, source URL, or publish date.

For list extraction, the result contains one structured record per item. A missing field should remain empty rather than being inferred from unrelated page content.

## Bot ID

Every Bot has a Bot ID. You can find it in either of these ways:

* Open `Bots` and move the pointer over the Bot card to reveal its ID and copy button.
* Open the Bot and find its ID in the Bot page URL in the browser address bar.

<img alt="Find and copy a Bot ID from the Bots page" />

Use the Bot ID when an integration needs to identify which Bot to run. BrowserAct Cloud uses Bot and Bot ID consistently as the user-facing object and identifier.

## Task ID

Every Task has a unique Task ID. It identifies one specific build, test, or run.

Open the Bot, select `History`, and find the Task ID in the `ID` column. You can also view it in the Task details.

<img alt="Find a Task ID in the Bot History" />

Use the Task ID when reviewing a specific execution or sharing an issue with BrowserAct Support. A Task ID does not replace the Bot ID used to identify which Bot to run.

## Bot and Task

```text theme={null}
Bot = reusable automation
Task = one build, test, or run record
Result = structured output from a completed run
```

A Bot can have many Tasks. Deleting or changing a Bot does not turn its previous Tasks into new Bots.


# Improve a Bot
Source: https://docs.browseract.com/bot/improve/improve-a-bot



> **Availability:** `Improve Bot` is available only for Agent Built Bots. It is not available for Workflow Built Bots. To update a Workflow Built Bot, open its Workflow Builder and modify the relevant nodes.

Use `Improve Bot` when an existing Agent Built Bot no longer fully matches what you need. For example, you may want to:

* Add new extraction fields, such as social-media links or contact details
* Rename, remove, or change existing output fields
* Change filters, limits, keywords, or other configurable inputs
* Adjust the pages or navigation path the Bot uses
* Update the Bot after the target website or required result has changed

Describe the change in natural language instead of rebuilding the Bot from the beginning. BrowserAct builds and tests the update as a draft, while the current `Live` version remains available for runs. The update is used by future runs only after you review and publish the draft.

## 1. Open Build and Select Improve Bot

1. Open the `Bots` menu and select the Agent Built Bot you want to modify.
2. Open the `Build` tab.
3. Review the current `Live` version and select `Improve Bot`.

The Build page also lists previous published versions for reference.

<img alt="Open Build and select Improve Bot" />

## 2. Describe the Change

Enter the specific improvement you need and send the request. Include the fields, behavior, or conditions that should change.

Example:

> I want to add extra extraction fields to also capture companies' social-media contact information.

BrowserAct creates a draft, updates the Bot, and tests the new behavior. The existing `Live` version is not replaced during this step.

<img alt="Describe the improvement in the draft" />

## 3. Review and Publish the Draft

Review the updated behavior and test data. When the result is ready:

1. Select `Publish` on the draft.
2. Confirm the publication.

<img alt="Publish the improved draft" />

The published draft becomes the new `Live` version and is used for new runs. The previous version moves to History and remains available for review.

<img alt="Confirm that the draft will be used for new runs" />

<img alt="Review the new Live version and previous version history" />

## 4. Run the Updated Bot

Open the `Run` tab. The Run page automatically displays and uses the latest `Live` version; the version is not selectable on this page.

Review the updated inputs and browser settings, then select `Run`. Future runs use the newly published version until another draft is published.

<img alt="Run the latest published version" />


# Manage Bots
Source: https://docs.browseract.com/bot/manage/manage-bots



Open `Bots` to find and manage the Bots in your BrowserAct account.

## Browse, Search, and Filter

Use the search field to find a Bot by name. Select `All`, `Agent-built`, or `Workflow-built` to filter the Bot list by build method.

Each Bot card shows its name, description when available, Bot ID, and available last-run information.

<img alt="Browse Bots and find the Bot ID" />

## Copy a Bot ID

Use the copy control beside the Bot ID. The Bot ID identifies the Bot in supported integrations and developer workflows.

## Bot Actions

Select the three-dot menu in the lower-right corner of a Bot card to access the available actions:

<img alt="Open the three-dot menu on a Bot card" />

* `Edit`: update available Bot details.
* `Build`: open the Bot's build experience.
* `Run`: start the Bot with the required inputs.
* `Browser Settings`: change the browser and network environment used by future tasks.
* `Delete`: permanently remove the Bot when deletion is allowed.

## View the Last Run

The Bot card shows the available last-run time. Open Tasks for detailed status, inputs, results, failure information, and usage records.

## Delete a Bot

Delete only when the Bot is no longer needed. Confirm the exact Bot before deleting it.


# Run an Agent Built Bot
Source: https://docs.browseract.com/bot/run/run-agent-built-bot



Run a published Agent Built Bot using its latest `Live` version.

## Before You Run

Confirm that:

* The Bot has a published version marked `Live`.
* The browser and proxy settings match the target website.
* Required Bot inputs have valid values.
* Your account has enough credits for the run.

## Start a Run

1. Open `Bots` and select the Agent Built Bot.
2. Open the `Run` tab.
3. Enter the required input values.
4. Review the browser configuration.
5. Select `Run`.

The Run page automatically uses the latest published `Live` version. The version displayed on this page is not selectable.

The run creates a Task. The latest run appears in the Run history area with available duration, creation time, and credit usage.

<img alt="Run the latest Live version of an Agent Built Bot" />

## Runs Started by Integrations

The Run history area can distinguish available channels such as direct Run, Make, n8n, and Zapier. The displayed channels depend on how the Bot was started.

Select `See all history` or open the Bot's `History` tab to review more records.


# Run a Workflow Built Bot
Source: https://docs.browseract.com/bot/run/run-workflow-built-bot



Run a published Workflow Built Bot from its `Run Task` page.

## Before You Run

Confirm that:

* The Workflow Built Bot has been published.
* Required input parameters have valid values.
* The default browser and proxy settings match the target website.
* Your account has enough credits for the run.

## Start a Run

1. Open `Bots` and select the Workflow Built Bot.
2. Open the `Run Task` tab.
3. Enter the required input parameters.
4. Review the default browser and proxy settings.
5. Select `Run`.

The run creates a Task. Recent runs appear in the Run History area on the same page.

<img alt="Enter inputs and run a Workflow Built Bot" />

Select `See all history` or open the Bot's `History` tab to review more records.


# View Run History
Source: https://docs.browseract.com/bot/run/view-run-history



Run History records the build and run activity associated with a Bot.

## Open Run History

1. Open `Bots` and select the Bot.
2. Select the `History` tab.

You can also select `See all history` from the Run tab after starting a Bot.

<img alt="View Bot build and run history" />

## Find a Record

Use the available controls to narrow the list:

* Date range
* Channel
* Additional channel filters shown by the current product
* Search

## Information in Each Record

A history row can show:

* Task ID
* Status
* Bot type
* Channel, such as Run or Build
* Request or run name
* Steps when available
* Credits used
* Creation time
* Available record actions

## Review a Completed Run

Locate the record by date, channel, or search. Confirm that its status is `Completed`, then use the available action to inspect or download the result.

Build records and Run records may appear in the same History view. Use the Channel filter to separate them when needed.


# Configure Schedule Emails
Source: https://docs.browseract.com/bot/schedules/configure-schedule-emails

Choose when BrowserAct should email scheduled Bot results.

Schedule emails help you receive Bot results without manually checking every scheduled run.

Schedule result emails are sent to the email address linked to your BrowserAct account by default. You can check the recipient under `When to email results` when creating a schedule.

## Email Options

## When Results Change

Choose `When results change` when you only want to be notified after BrowserAct detects a result change.

The first successful scheduled run creates the baseline. Later successful runs are compared with the previous successful result.

Use this option when you want to monitor changes such as:

* Product price changes
* Product availability changes
* New listings or removed listings
* Updated lead or market data
* Changed search results

## After Every Successful Run

Choose `After every successful run` when you want to receive an email each time the schedule runs successfully.

Use this option when every scheduled result matters, even if the result is the same as the previous run.

## Don't Send Result Emails

Choose `Don't send result emails` when you do not want emails for successful scheduled runs.

The schedule can still run, and run records can still be reviewed from BrowserAct.

## When Results Meet a Condition

Choose `When results meet a condition` when you only want an email in a specific situation.

This option is currently supported only for schedules created from Agent Built Bots.

After selecting this option, describe the condition the result must meet.

Example conditions:

```text theme={null}
Email me when the product price drops below 50 dollars.
```

```text theme={null}
Email me when the item becomes available.
```

```text theme={null}
Email me when a new job listing includes remote work.
```

BrowserAct evaluates the scheduled run result against the condition and sends an email only when the condition is met.

## Failure Emails

`Email me if a run fails` controls whether BrowserAct sends an email when a scheduled run fails.

This setting is separate from successful result emails. Turning off result emails does not necessarily mean failure emails are turned off.


# Schedule Bot Runs
Source: https://docs.browseract.com/bot/schedules/schedule-bot-runs

Create schedules to run published BrowserAct Bots automatically and receive result emails based on changes, successful runs, or Agent Built Bot conditions.

Use schedules to run a published BrowserAct Bot automatically.

A schedule stores the timing, inputs, email settings, retry settings, and run history for a recurring Bot run. You can create multiple schedules for the same Bot when you want to monitor different products, pages, keywords, or URLs.

Schedules are useful when you want BrowserAct to:

* Check product prices or availability on a recurring basis
* Track search results, listings, leads, jobs, or market data
* Refresh data at a fixed time or interval
* Email you when results change, or when an Agent Built Bot result meets a condition

Schedules run Bots based on the timing you configure. They are not real-time monitoring.

## Step 1: Open the Bot

1. Go to `Bots`.
2. Select the Bot you want to schedule.
3. Open the Bot detail page.

<img alt="Open the Bot you want to schedule" />

## Step 2: Open Schedules

1. Click the `Schedules` tab.
2. Click `Create schedule`.

<img alt="Open Schedules and create a schedule" />

## Step 3: Set Schedule Timing

In the `Timing` step, configure when BrowserAct should run the Bot.

* `Name`: enter a name for this schedule.
* `Frequency`: choose how often the Bot should run. Supported options are `Hour`, `Day`, and `Week`.
* `Run on`: choose the days when the schedule should run.
* `Trigger time` or `Trigger window`: choose when the run should be triggered.
  * Use a specific time if the Bot should run at a fixed time.
  * Use a time window if the Bot can run during a range, such as 9:00 AM to 6:00 PM.
  * Select `All day` if the Bot can run at any time during the day.
* `Time zone`: choose the time zone used to calculate the schedule.

Click `Next` when the timing settings are ready.

<img alt="Set the schedule timing" />

<img alt="Choose frequency and trigger window" />

## Step 4: Configure Schedule Inputs

In the `Inputs` step, confirm the values this schedule will use each time it runs.

The fields shown here come from the published Bot's input settings. BrowserAct fills in default values when they are available. You can keep the defaults or update the values for this schedule.

For example, a product tracking Bot may include inputs such as:

* `marketplace_url`: the marketplace base URL, such as `https://www.amazon.com`
* `asin`: the Amazon product ASIN to open and read

If a required input does not have a default value, enter a valid value before continuing.

<img alt="Configure schedule inputs" />

### Monitor multiple products or URLs

Create a separate schedule for each set of inputs you want to monitor.

For example, if you want to monitor multiple products, create one schedule for each product and enter a different product identifier, URL, or input value in the `Inputs` step.

Each schedule keeps its own timing, inputs, email settings, retry settings, and run history.

Click `Next` after the inputs are ready.

## Step 5: Configure Email & Retry

In the `Email & retry` step, choose when BrowserAct should email schedule results and how failed runs should be handled.

Schedule result emails are sent to the email address linked to your BrowserAct account by default. You can check the recipient shown under `When to email results`.

### When to email results

Choose one result email option:

* `When results change`: send an email only when the schedule finds a change compared with the previous successful result.
* `After every successful run`: send an email after each successful scheduled run.
* `Don't send result emails`: do not send emails for successful scheduled runs.
* `When results meet a condition`: for Agent Built Bots only, send an email only when the run result meets the condition you describe.

<img alt="Configure result emails and retry settings" />

### Condition-based email notifications

Use `When results meet a condition` when you only want to be notified in a specific situation.

This option is currently supported only for schedules created from Agent Built Bots.

After selecting this option, describe the condition the result must meet.

```text theme={null}
Email me when the product price drops below 50 dollars.
```

BrowserAct evaluates the scheduled run result against this condition and sends an email only when the condition is met.

<img alt="Describe a condition for result emails" />

### Retry and failure alerts

Use the retry and failure options based on how you want failed runs to be handled:

* `Retry failed runs once`: automatically create one retry run if a scheduled run fails.
* `Email me if a run fails`: send an email when a scheduled run fails.

Click `Create schedule` after the email and retry settings are ready.

## After Creating a Schedule

After the schedule is created, it appears in the Bot's `Schedules` tab.

The schedule list shows information such as:

* `Name / ID`
* `Timing`
* `When to email results`
* `Schedule status`
* `Needs attention`
* `Last triggered`

Use this list to check whether a schedule is enabled, whether it needs attention, and when it was last triggered.

<img alt="View multiple schedules for one Bot" />

## Review Exception Notifications

You can also review exception notifications from the global notification panel.

1. Click the bell icon in the top navigation.
2. Select the `Exceptions` tab.
3. Review any exception messages that need attention.

The `Exceptions` tab is useful when you want to check whether a scheduled run or recurring Bot setup has produced an issue that needs follow-up. Exception messages can show why a scheduled task could not be created and which Bot or schedule is related to the issue.

<img alt="Open exception notifications" />


# Schedule FAQ
Source: https://docs.browseract.com/bot/schedules/schedule-faq

Answers to common questions about BrowserAct Bot schedules.

## Can I create multiple schedules for one Bot?

Yes. You can create multiple schedules for the same Bot.

Use this when you want to run the same Bot with different inputs, such as monitoring multiple products, pages, keywords, or URLs.

Each schedule keeps its own timing, inputs, email settings, retry settings, and run history.

## How do I set up monitors on multiple URLs at once? (Bulk Monitor)

If you want to monitor multiple URLs, products, or pages, create one schedule for each set of inputs.

For example, if your Bot tracks an Amazon product by `marketplace_url` and `asin`, create a separate schedule for each product and enter a different `asin` in the `Inputs` step.

This lets each monitored item keep its own schedule, notification rule, retry setting, and run history.

## Which frequencies are supported?

Schedules currently support `Hour`, `Day`, and `Week`.

## Do I need to update a schedule after the Bot is updated?

Usually, no. A schedule continues to run the published Bot with the timing, inputs, email settings, and retry settings saved in that schedule.

Review the schedule if the Bot update changes required inputs, removes an input, changes the meaning of an input, or changes the result structure used by a condition-based email rule.

If the updated Bot needs different values, open the schedule and update its `Inputs` and notification settings before the next run.

## Are schedules real-time monitoring?

No. Schedules run Bots based on the timing you configure. They are not real-time monitoring.

## Where are result emails sent?

Result emails are sent to the email address linked to your BrowserAct account by default.

You can check the recipient shown under `When to email results` when creating a schedule.

## Can I send emails only when a condition is met?

Yes, for Agent Built Bots.

Choose `When results meet a condition`, then describe the condition that should trigger an email. This option is currently supported only for schedules created from Agent Built Bots.

For example, you can ask BrowserAct to email you when a product price drops below a certain amount, when an item becomes available, or when a result includes a specific keyword.

## What happens if a scheduled run fails?

If `Retry failed runs once` is enabled, BrowserAct automatically creates one retry run after a scheduled run fails.

If `Email me if a run fails` is enabled, BrowserAct sends a failure email when a scheduled run fails.

## Where can I check exception notifications?

Click the bell icon in the top navigation, then open the `Exceptions` tab.

Use this tab to review exception messages that need attention, including issues related to scheduled or recurring Bot runs. Exception messages can include the reason and the related Bot or schedule.

## Will a schedule enter the queue if credits are insufficient?

No. If the schedule cannot create a run because credits are insufficient, the run is not added to the task queue.

Add credits or adjust your account setup before the next scheduled run can be created.

## Can I use schedules with both Agent Built Bots and Workflow Built Bots?

Yes. Schedules can be created for published BrowserAct Bots.

The available inputs and result behavior depend on the Bot you schedule.

## Can I still use Make scheduling?

Yes.

Use BrowserAct schedules when you want native scheduled Bot runs and result emails inside BrowserAct.

Use Make scheduling when you want a Make scenario to trigger BrowserAct and continue into other Make modules.


# View and Manage Tasks
Source: https://docs.browseract.com/bot/tasks/view-manage-tasks



Each Bot build or run creates a Task. Open `Tasks` to review records across all Bots. If you only want to view the task records for a specific Bot, you can also open that Bot and select `History`.

<img alt="View tasks across all Bots" />

## Filter Tasks

Use the available filters to narrow the task list:

* Date range
* Channel
* MCP Server when applicable
* Type
* Search when available

## Task Information

Each row can show:

* Task ID
* Status
* Bot type
* Channel, such as `Build` or `Run`
* Bot name
* Task request or input
* Steps when available
* Credits used

## Review a Task

Select a Task or use its available actions to review task details and results. The available actions depend on the task type and status.

Use the Task ID when locating a specific record or contacting BrowserAct Support.


# Quick Start
Source: https://docs.browseract.com/bot/workflow-built/build-your-first-bot

Build and run a Bot by connecting browser actions and data operations in the visual Workflow Builder.

## Video Tutorial

[![Watch Build Your First Workflow in 5 Minutes](https://i.ytimg.com/vi/8fYWAQhm3QU/hqdefault.jpg)](https://www.youtube.com/watch?v=8fYWAQhm3QU)

[Watch **Build Your First Workflow in 5 Minutes** on YouTube](https://www.youtube.com/watch?v=8fYWAQhm3QU).

## 1. Create a Workflow Built Bot

1. Select `Create`.
2. Under `Build with Workflow`, select `Open editor`.

<img alt="Open Build with Workflow from the Create menu" />

3. Enter an `AI Workflow Name` and an optional description.
4. Select `Create` to open the Workflow Builder.

<img alt="Name and create the Workflow Built Bot" />

***

## 2. Build the Workflow: Google Maps Example

A Workflow connects nodes that represent the actions you would perform on a real website. For example, use a **Visit Page** node when you need to open a page, and use a **Click Element** node when you need to click a button.

This tutorial uses Google Maps to demonstrate the complete process. The Bot searches for restaurants in a selected location and extracts structured data from the results.

**Inputs**

* **Country:** e.g., `USA`
* **Area:** e.g., `Avalon, CA`

**Browser Actions**

1. Open `https://www.google.com/maps`
2. Search `{Country} {Area}`
3. Click search icon
4. Click **Nearby**
5. Click **Restaurant**
6. Extract list data

**Output**

A CSV file containing:

* `name`
* `full_address`
* `star_rating`
* `review_count`
* `average_price_per_person_range`

*All steps below are performed on the Workflow Build page.*

### Step 1 - Start Node: Define Input Parameters

1. On the canvas, click the **Start** node.
2. In **Input Parameters**, add:
   * **Name:** `Country` | **Default Value:** `USA`
   * **Name:** `Area` | **Default Value:** `Avalon, CA`

<img alt="Configure the Start node and add the next action" />

### Step 2 - Visit Page: Open Google Maps

1. Click **+** on the canvas (or right-click) and choose [**Visit Page**](/bot/workflow-built/node-types/visit-node).
2. Connect it after **Start**.
3. Set URL to:

   ```
   https://www.google.com/maps

   ```

<img alt="Visit Page node configured for Google Maps" />

### Step 3 - Input Text: Search for the Location

1. Add an [**Input Text**](/bot/workflow-built/node-types/input-text-node) node and connect it after **Visit Page**.
2. In the page preview/selector, target the **top search bar**.
3. In Text to Input, enter: Country Area

   (This references the Start parameters).

<img alt="Input Text node configured for the Google Maps search" />

### Step 4 - Click Element: Navigate to Restaurants

Use one or more [**Click Element**](/bot/workflow-built/node-types/click-element-node) nodes to perform these three clicks in order:

1. **Search:** Click the magnifying-glass icon.
2. **Nearby:** Click the `Nearby` button.
3. **Restaurant:** Click the `Restaurant` category.

<img alt="Click Element nodes configured for the Google Maps example" />

### Step 5 - Extract Data: Scrape the Restaurant List

1. Add an [**Extract Data**](/bot/workflow-built/node-types/extract-data-node) node after the last Click Element node.
2. In the left restaurant list, select **one full restaurant item** as the sample.
3. Configure fields to extract:
   * `name`
   * `full_address`
   * `star_rating`
   * `review_count`
   * `average_price_per_person_range`

<img alt="Extract Data node configured for restaurant records" />

***

## 3. Publish & Run

Before executing the workflow, ensure your latest changes are saved and versioned.

1. **Publish Version:** Click the **Publish** button (top-right corner) and select **Publish as New Version** to save your current configuration.
2. **Enter Run Mode:** Click the **Run** tab (located next to the *Build* tab).

<img alt="Publish the Workflow Built Bot as a new version, then open Run" />

3. **Set Parameters:**
   * Country: `USA`
   * Area: `Avalon, CA`
4. **Execute:** Click **Start Run** and watch the nodes execute one by one.

You’re done when:

1. All steps show **Succeeded / ✔**.
2. The run result shows a **downloadable CSV file**.
3. The CSV contains rows like:

Code snippet

```
name,full_address,star_rating,review_count,average_price_per_person_range
Bluewater Avalon,306 Crescent Ave,4.3,2342,$30–50
Buffalo Nickel Inc,57 Pebbly Beach Rd,4.6,646,$20–30
...
```

<img alt="Review the completed workflow steps and download the CSV result" />

***

## 4. Common Roadblocks (Quick Fixes)

* **CSV is empty or has very few rows:**
  * Check the sample in [**Extract Data**](/bot/workflow-built/node-types/extract-data-node): it should be a full list item, not a tiny sub-element.
  * **Wait for load:** Add a short [wait](/bot/workflow-built/node-types/wait-node) before Extract Data if the list loads slowly.
* **Click Element does nothing:**
  * Re-select the actual clickable element (button/text) in the [Click Element node](/bot/workflow-built/node-types/click-element-node).
  * Confirm node order: Search → Nearby → Restaurant.
* **Run error and not sure why:**
  * Check URL in Visit Page is exactly `https://www.google.com/maps`.
  * Ensure Run parameters (Country/Area) are filled.
  * Ensure no node has missing config ([Click Element](/bot/workflow-built/node-types/click-element-node), etc.).

### Need Help?

If the issue continues, [contact BrowserAct Support](../../support/contact-support.mdx) or create a ticket in [Discord](https://discord.com/invite/UpnCKd7GaU). Include:

* A short description of your goal
* A screenshot of the error
* The Task ID

***

## Next Steps

Run the Bot again with different input values to confirm that the workflow can be reused for other locations.

For example:

| Country | Area |
| - | - |
| USA | New York |
| Japan | Shibuya |

Once the workflow runs successfully with new inputs, continue to [Node Types](./node-types/index.md) to learn how to build other browser interactions, or see [Run a Workflow Built Bot](../run/run-workflow-built-bot.md) for more ways to run and review a Bot.


# Case 4: Precise Scraping with Conditional Filtering
Source: https://docs.browseract.com/bot/workflow-built/case-studies/condition-filtering

Learn how to filter and scrape only specific items from a list based on criteria (e.g., discounts) using conditional logic, with eBay as an example.

## 1. Case Overview

This case demonstrates a very common e-commerce scenario: The list contains many items, but we only want to scrape those that **"meet specific criteria"** and skip the rest.

In this example, we open an eBay search result page for laptops and check the first 10 items one by one:

* **Check:** Does this item have a "Bulk Savings" discount text? (e.g., *Save up to 10% when you buy more*).
* **If Yes:** Record the **Product Name + Price**.
* **If No:** Skip this item immediately and look at the next one.

**Key Logic:**

1. [**Loop List**](/bot/workflow-built/node-types/loop-list-node)**:** Responsible for focusing on each product card sequentially.
2. [**Condition**](/bot/workflow-built/node-types/condition-node)**:** Performs a judgment on each product.
   * **True:** Execute subsequent scraping nodes.
   * **False:** Do nothing, automatically skipping to the next product.

Although this case uses eBay, this **"List Traversal + Condition Filtering"** logic is universal for any website where only a subset of items in a list match your needs, such as:

* Scraping only discounted items.
* Scraping only items with a "Prime" badge.
* Scraping only content tagged "New" or "HOT".

<img alt="Gemini_Generated_Image_4qya5i4qya5i4qya.png" />

## 2. Detailed Steps

### 1. [Visit Page](/bot/workflow-built/node-types/visit-node) (Open Search Results)

* **Objective:** Simulates opening a browser and entering the eBay search URL.
* **Configuration:**
  * **URL:** `https://www.ebay.com/sch/i.html?_nkw=laptop`
  * **Tab:** Select **Current Tab Access**.
  * **In Abnormal Situation:** Keep **Stop Task**.

<img alt="PixPin_2025-12-04_11-32-51.png" />

### 2. [Loop List](/bot/workflow-built/node-types/loop-list-node) (Traverse Product List)

* **Objective:** Tell the AI: "This entire area is the product list. Please process items one by one."
* **Configuration:**
  * **List Region:** Select the main search result area in the middle of the interface. Description example: `In the middle of the interface, the search results list`.
  * **Max items to focus:** Enter `10` (focus on the first 10 items for quick testing).
  * **Auto-click "Load More":** Leave unchecked (eBay uses pagination, not infinite scroll).
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Tip:** As long as the Loop List region is selected accurately, the subsequent logic can be reused regardless of how complex the list is.

<img alt="PixPin_2025-12-04_11-32-59.png" />

### 3. [Condition](/bot/workflow-built/node-types/condition-node) (Check for Bulk Discount)

* **Important:** This node must be placed **inside** the **Loop List** node. This ensures the condition applies to the "currently focused product card."
* **Objective:** Check the description area of the current product: Is there a bulk purchase discount prompt like *"Save up to 10% when you buy more"*?
* **Configuration:**
  * **Condition Description:** `Are there discounts for bulk purchases? For example, "Save up to 10% when you buy more."`
  * **In Abnormal Situation:** Keep **Stop Task**.
* **Logic Explanation:**
  * **True Branch:** The product has the discount text → Considered a "matching item," proceed to scrape.
  * **False Branch:** The product lacks this text → Do nothing, automatically return to Loop List to check the next item.

<img alt="PixPin_2025-12-04_11-35-49.png" />

### 4. [Extract Data Item](/bot/workflow-built/node-types/extract-data-item-node) (True Branch: Scrape Matching Items)

* **Context:** This node is placed on the **True** branch of the Condition node.
* **Objective:** Copy the core information of this "discounted product."
* **Configuration:**
  * **Data Field:** Define the fields you need, for example:
    * **Product Name**
    * **Product Price**
  * **Selection:** Select the title and price elements on the current product card.
  * **Filtering Criteria:** Leave unchecked.
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Note:** The **Extract Data Item** only applies to the "current item." The Loop List handles moving the focus to the next item automatically.

<img alt="PixPin_2025-12-04_11-36-01.png" />

### 5. Configure Output Results in Start

* **Objective:** After the Loop List finishes processing the first 10 items, compile all "matching items" into structured data.
* **Configuration:**
  * In the **Start** node, select **CSV** or **JSON** as the **Default Output Format**.
  * Enable **Convert to file format** if you want a downloadable file.
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Result:** The final export will be a list containing only the "Discounted Items" with their names and prices.

<img alt="PixPin_2025-12-04_11-36-09.png" />

## 3. Human Operation vs. AI Nodes

To better understand the workflow, compare how a human operates versus how the AI nodes are structured.

| **Your Action (Human Operation)** | **Corresponding AI Node** | **Function Description** |
| :- | :- | :- |
| **Open browser**, enter eBay laptop search URL. | **Visit Page** | Opens the target search result page to start the task. |
| **Look** at the long list of search results, ready to check them one by one. | **Loop List** | Tells the AI: "This entire area is the product list," and iterates through items. |
| **Glance** at a product card: Does it say "Save up to 10%..."? | **Condition** (Inside Loop List) | Judges the current item: Has Discount → True; No Discount → False. |
| **If Yes (True):** Write down the name and price in your notebook. | **Extract Data Item** (True Branch) | Executes only when Condition is True, extracting Product Name and Price. |
| **If No (False):** Ignore it and look at the next item. | **False Branch** (Empty) | No action is taken. The Loop List automatically moves focus to the next item. |
| **Final Step:** Save the list of "Discounted Items" you collected. | **Start output settings** | Returns all recorded data in the selected CSV/JSON format. |

### Summary

The essence of this case is **"Filter first, then Scrape"** rather than scraping everything.

1. **Loop List** handles "Looking one by one."
2. **Condition** handles "Do I want this?"
3. **Extract Data Item** handles "If I want it, write it down."

Whenever you have a requirement like **"Only scrape items that are On Sale / Prime / Specific Tag,"** you can simply build this **Loop List + Condition + Extract Data Item** combination.


# Case 1: Deep Scraping from List to Detail Pages
Source: https://docs.browseract.com/bot/workflow-built/case-studies/list-to-detail

Master the core automation pattern of traversing search results and extracting deep data from detail pages, using Amazon as a practical example.

## 1. Case Overview

This case study demonstrates the most core pattern in web automation: **"List Traversal + Detail Page Extraction."**

The core logic involves the AI first identifying a search result list, then sequentially entering each product's detail page (secondary page) to collect more complete and deep data fields, and finally exporting them into a structured table.

This case uses **Amazon** as an example to demonstrate a complete "Search-List-Detail" scraping workflow. Please note that while Amazon is the subject, the underlying **automation logic** is universally applicable to any website with a "List Page + Detail Page" structure (e.g., recruitment, real estate, and news sites).

<img alt="Gemini_Generated_Image_rl8gq6rl8gq6rl8g.png" />

## 2. Detailed Steps

### 1. [Visit Page](/bot/workflow-built/node-types/visit-node) (Open Website)

* **Objective:** Simulates opening a browser and entering a specific website address.
* **Configuration:**
  * **URL:** Enter the Amazon homepage address: `https://www.amazon.com/`.
  * **Tab:** Select **Current Tab Access** (operate within the current tab).

<img alt="image.png" />

### 2. [Click Element](/bot/workflow-built/node-types/click-element-node) (Handling Random Pop-ups)

* **Objective:** Handles potential interruptions like "Continue Shopping" prompts or ads. If a pop-up appears, the AI closes it; otherwise, it ignores the step.
* **Configuration:**
  * **Where to click:** Select the close button of the interfering pop-up.
  * **Key Setting:** Under **In Abnormal Situation**, select **Ignore this node and continue execution**.
  * **Why this setting:** This instructs the AI to dismiss the pop-up if present, but proceed seamlessly if the pop-up is absent (intelligent fault tolerance).

<img alt="PixPin_2025-12-03_20-29-55.png" />

### 3. [Input Text](/bot/workflow-built/node-types/input-text-node) (Search Keywords)

* **Objective:** Locates the search box, types the keyword, and initiates the search.
* **Configuration:**
  * **Input Location:** Select the search bar at the top of the page.
  * **Input Text:** Enter `laptop`.
  * **Key Setting:** Check **Press "Enter" after typing**. This allows the AI to automatically submit the search after typing, eliminating the need for a separate "Click Search Button" step.

<img alt="PixPin_2025-12-03_20-31-58.png" />

### 4. [Loop List](/bot/workflow-built/node-types/loop-list-node) (Identify List)

* **Objective:** Identifies the collection of products to be processed, preparing the AI to iterate through them one by one.
* **Configuration:**
  * **List Range:** Select the area containing all the products.
  * **Limit:** For testing purposes, enter `10` to limit the process to the first 10 items and optimize execution time.

<img alt="PixPin_2025-12-03_20-32-54.png" />

### 5. [Click Element Item](/bot/workflow-built/node-types/click-element-item-node) (Enter Detail Page)

* **Objective:** Clicks on the title of the current product within the list to navigate to its detailed view.
* **Configuration:**
  * **Note:** This step must be placed **inside** the **Loop List** node.
  * **Where to click:** Click on the product title text.

<img alt="PixPin_2025-12-03_20-33-53.png" />

### 6. [Extract Data](/bot/workflow-built/node-types/extract-data-node) (Copy Data)

* **Objective:** Captures specific information (such as Brand, Model, Memory) from the detail page.
* **Configuration:**
  * **What to extract:** Define the target fields (e.g., Brand, Model) and select the corresponding content on the page.

<img alt="PixPin_2025-12-03_20-34-39.png" />

### 7. Configure the Output File in Start

* **Objective:** Compiles the extracted data and saves it into a structured file format.
* **Configuration:**
  * In the **Start** node, set **Default Output Format** to **CSV**.
  * Enable **Convert to file format**.

## 3. Human Operation vs. AI Nodes

To help you apply this method to other websites, let's compare **Human Logic** with **AI Logic**. You will observe that the AI's process mirrors human behavior.

| **Your Action (Human Operation)** | **Corresponding AI Node** | **Function Description** |
| :- | :- | :- |
| **Open browser**, enter URL. | **Visit Page** | The start of the task. |
| **See an ad pop-up**, close it immediately. | **Click Element** (Set to Ignore) | "Intelligent Fault Tolerance": ignore if absent, close if present. |
| **Type in search box**, press Enter. | **Input Text** (Check "Enter") | Triggers the search to find your target. |
| **Look at the rows** of products on the screen. | **Loop List** | Tells the AI: "These identical-looking items are the list we need to process." |
| **Click the 1st title** with the mouse. | **Click Element Item** | Navigates from the list page to the detail page (secondary page). |
| **Copy and paste** detailed params to Excel. | **Extract Data** | The core action of scraping/grabbing data. |
| **Save** the result file. | **Start output settings** | Returns the data in the selected format. |

### Summary

Regardless of the website you encounter in the future, as long as you want to implement a **"Search List -> Click to View Details"** workflow, simply replicate the block assembly logic outlined above.


# Case 3: Auto-expanding Long List and Scraping
Source: https://docs.browseract.com/bot/workflow-built/case-studies/load-more

Automate data extraction from long lists that require clicking Load More or scrolling, using Crutchfield as an example.

## 1. Case Overview

This case demonstrates a very frequent pattern in web automation: **Automatically loading more content in a long list and collecting data until a condition is met.**

Typical characteristics of this list type include:

* The page retains a single "Load More" button that appears continuously.
* Clicking it appends a batch of new content to the bottom of the same page.
* Alternatively, simply scrolling down triggers the automatic loading of more data, without a traditional pagination bar.

In this case, we focus exclusively on Long Lists:

Using the Crutchfield TV product list as an example, we will demonstrate how to use Loop List + Auto-click Load More to continuously expand the list, traverse each product, and collect data on the same page.

**Note:** This pattern applies to all multi-page lists that rely on "Load More / Infinite Scroll." As long as the page URL doesn't change and content is just appended downwards, you can use this logic.

<img alt="Gemini_Generated_Image_ah9lmuah9lmuah9l.png" />

## 2. Detailed Steps

### 1. [Visit Page](/bot/workflow-built/node-types/visit-node) (Open TV Product List)

* **Objective:** Open the Crutchfield TV list page directly, avoiding the need to navigate step-by-step from the homepage.
* **Configuration:**
  * **URL:** `https://www.crutchfield.com/S-YkA30Gowvuu/shopsearch/TV.html?fa=1&pg=1` (You can replace this with any other category or search result page; the logic is identical).
  * **Tab:** Select **Current Tab Access**.
  * **In Abnormal Situation:** Keep **Stop Task** (if the list page cannot be accessed, there is no point in continuing).

<img alt="PixPin_2025-12-04_11-30-25.png" />

### 2. [Loop List](/bot/workflow-built/node-types/loop-list-node) (Traverse List + Auto-click Load More)

* **Core Logic:** This node is the heart of this pattern.
* **Objective:** Tell the AI: "This entire area is a product list. Please process items one by one. If a 'Load More' button appears at the bottom, click it automatically to load more products until the limit is reached or there is no more content."
* **Configuration:**
  * **List Region:** Select the entire list area containing the TV product cards on the page. Description example: `The main TV product list in the middle of the page.`
  * **Max items to focus:** Enter `10` (for example) to traverse at most the first 10 products.
  * **Load More / Auto-load:** Check the option **Auto-click "Load More" button when present to load more items**.
    * **Meaning:** When the Loop List detects a "Load More" button at the bottom, it will automatically click it, wait for new products to load, and then continue traversing.
  * **In Abnormal Situation:** Keep **Stop Task**.
  * **Note:** You do **not** need a separate "Pagination" node. The **Loop List** node handles both the traversal and the "Load More" clicking action automatically.

<img alt="PixPin_2025-12-04_11-30-31.png" />

### 3. [Extract Data Item](/bot/workflow-built/node-types/extract-data-item-node) (Scrape Fields for Each Product)

* **Important:** This node must be placed **inside** the **Loop List** node so that it executes automatically for every product in the list.
* **Objective:** For the currently focused TV product card, extract specific fields such as Name, Price, and Rating.
* **Configuration:**
  * **Data Field Examples:** (Adjust based on the actual page)
    * **Product Name:** The title of the product.
    * **Price:** The current selling price.
    * **Rating:** User rating (if available on the page).
  * **Filtering Criteria:** Leave unchecked (unless you have specific filtering needs).
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Effect:** Every time the Loop List moves to a new product card, it triggers this **Extract Data Item** node to append that product's info to the result set.

<img alt="PixPin_2025-12-04_11-30-37.png" />

### 4. Configure Output in Start (Export All Products)

* **Objective:** Once the Loop List finishes traversal (reaching the "Max items" count or when no new products appear), compile all collected records into structured data.
* **Configuration:**
  * In the **Start** node, set **Default Output Format** to **CSV** or **JSON**.
  * Enable **Convert to file format** if you want a downloadable file.

## 3. Human Operation vs. AI Nodes

To better understand the workflow, compare how a human operates versus how the AI nodes are structured.

| **Your Action (Human Operation)** | **Corresponding AI Node** | **Function Description** |
| :- | :- | :- |
| **Open** Crutchfield's TV list page. | **Visit Page** | Opens the target list directly, skipping homepage navigation. |
| **Browse** the list from top to bottom. | **Loop List** | Locks onto the product list area and traverses items sequentially. |
| **Look** at the current product and copy Name, Price, Rating. | **Extract Data Item** (Child of Loop List) | Extracts fields from the currently focused card and adds them to the results. |
| **Scroll** to the bottom, see "Load More," and click it. | **Loop List** (Built-in Auto-click) | Automatically detects and clicks "Load More" to append items. |
| **Continue** scrolling and copying new items as they appear. | **Loop List** (Driver) | Drives the "Expand + Traverse" process within the same page. |
| **Stop** when enough items are collected, and organize the list. | **Start output settings** | Returns all collected results in CSV/JSON. |

## 4. Summary

Whenever you encounter a **"Load More / Infinite Scroll"** multi-page list with the characteristic: **"The page doesn't change, but clicking 'Load More' or scrolling down appends more content,"** you can directly apply this Case 3 pattern:

1. Use **Loop List** to lock the list region.
2. Check the **Auto-click Load More** option.
3. Place an **Extract Data Item** node inside the Loop List.
4. Use the output settings in **Start** to select the result format.

This ensures a stable, automatic scraping process for all "single-page expansion" lists.


# Case 5: Precise Scraping with Multi-Dimensional Filtering
Source: https://docs.browseract.com/bot/workflow-built/case-studies/multi-dimensional-filtering

Learn how to combine search keywords, category filters, and AI-based content filtering for precise data extraction, using Amazon as an example.

## 1. Case Overview

Often, we don't want to "scrape all products." Instead, we want to:

Narrow down the scope first, and then only keep the small subset of results that "truly meet the criteria."

A typical operation usually involves **three layers of filtering**:

1. **Search Box Filtering:** First, input keywords (e.g., "laptop") in the search box to narrow down from the entire site to a specific category.
2. **Category Filtering (Sidebar/Conditions):** Check filter conditions on the left or top of the page, such as "Hard Drive Size 1TB" or "CPU Brand Intel".
3. **Content-Level Filtering (AI Filtering):** Even if the website has already filtered the results, we may still only want items that satisfy a specific text condition. For example: *Only keep laptops that mention "Energy efficiency."*

This case uses the **Amazon laptop search page** as an example to demonstrate a complete **"Three-Layer Filtering + Scraping"** workflow:

1. Search for "Laptop" in the search box.
2. Check "Hard Drive Size" and "CPU Brand" in the left sidebar filters (controlled by parameters).
3. Traverse the search result list and only collect laptop information that contains energy-efficiency-related content.
4. Export the filtered results as a CSV table.

Applicability:

This logic works for any common website (E-commerce, Recruitment, News, SaaS Dashboards) that features:

* A Search Box
* A Category/Filter Panel
* A List + Item Descriptions

<img alt="Gemini_Generated_Image_ekglncekglncekgl.png" />

## 2. Detailed Steps (Step-by-Step Guide)

### 1. Start (Optional: Parameterize Filter Conditions)

* **Recommendation:** This step is optional but highly recommended to make the workflow flexible and reusable.
* **Objective:** Define "filter condition parameters" in the Start node so subsequent nodes can reference them using `/parameter_name`.
* **Example Parameters:**
  * `hard_drive_size`: e.g., "1 TB"
  * `cpu_manufacturer`: e.g., "Intel"
* **Benefit:** When reusing the workflow, users only need to change the parameters instead of editing individual nodes.

<img alt="PixPin_2025-12-04_11-40-13.png" />

### 2. [Visit Page](/bot/workflow-built/node-types/visit-node) (Open Amazon Homepage)

* **Objective:** Open the Amazon homepage and prepare to search.
* **Configuration:**
  * **URL:** `https://www.amazon.com/`
  * **Tab:** Select **Current Tab Access**.
  * **In Abnormal Situation:** Keep **Stop Task**.

<img alt="PixPin_2025-12-04_11-40-19.png" />

### 3. [Input Text](/bot/workflow-built/node-types/input-text-node) (Search Box Filter: Keyword = Laptop)

* **Layer 1 Filtering:** Use the site's built-in search box to lock the scope to "Laptops."
* **Objective:** Find the top search box, type "Laptop," and press Enter.
* **Configuration:**
  * **Input Field Position:** Select the **Top Search Box**.
  * **Text to Input:** Enter `Laptop` (or reference a parameter like `/keyword`).
  * **Setting:** Check **Press "Enter" after typing**. This triggers the search automatically.
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Result:** The page changes from the "Site Homepage" to the "Laptop Search Result List."

<img alt="PixPin_2025-12-04_11-40-26.png" />

### 4. [Scroll to Element](/bot/workflow-built/node-types/scroll-to-element-node) (Scroll to Filter Area: HDD Size)

* **Layer 2 Filtering - Step 1:** Bring the left filter panel into view.
* **Objective:** Scroll down the page until the "Hard Drive Size" section appears on the left.
* **Configuration:**
  * **Description:** `Scroll down to see the Hard Drive Size filter on the left`.
  * **Max Scroll Iterations:** e.g., `10 screens`.
  * **In Abnormal Situation:** Keep **Stop Task**.

<img alt="PixPin_2025-12-04_11-40-33.png" />

### 5. [Click Element](/bot/workflow-built/node-types/click-element-node) (Select HDD Size Filter)

* **Objective:** Under the "Hard Drive Size" category, click the desired capacity option (e.g., 1 TB).
* **Configuration:**
  * **Description:** `Click on the /hard_drive_size option under Hard Drive Size category on the left`.
  * **Action:** Select the corresponding checkbox on the page. (If using the `/hard_drive_size` parameter, the AI will match the option based on the text).
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Result:** The product list is now filtered by the website to show "Laptops + Specified HDD Size."

<img alt="PixPin_2025-12-04_11-40-39.png" />

### 6. [Scroll to Element](/bot/workflow-built/node-types/scroll-to-element-node) (Scroll to CPU Brand Filter Area)

* **Objective:** Scroll down further until the CPU manufacturer filter section appears.
* **Configuration:**
  * **Description:** `Scroll down to see the CPU manufacturer filter on the left`.
  * **Max Scroll Iterations:** `10 screens`.
  * **In Abnormal Situation:** Keep **Stop Task**.

<img alt="PixPin_2025-12-04_11-40-46.png" />

### 7. [Click Element](/bot/workflow-built/node-types/click-element-node) (Select CPU Brand Filter)

* **Objective:** Under the CPU Manufacturer category, click the specified brand (e.g., Intel, or from a parameter).
* **Configuration:**
  * **Description:** `Click on the /cpu_manufacturer option under CPU Manufacturer category`.
  * **Action:** Select the corresponding brand checkbox on the page.
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Milestone:** The first two layers of filtering are complete using native website features: Search Keywords + Left Sidebar Filters.

<img alt="PixPin_2025-12-04_11-40-52.png" />

### 8. [Loop List](/bot/workflow-built/node-types/loop-list-node) (Traverse Filtered Product List)

* **Layer 3 Start:** In the filtered result list, perform "Content-Level Filtering."
* **Objective:** Treat the middle product search results as a list and traverse each item sequentially.
* **Configuration:**
  * **List Region:** Select the product card area in the middle. Description: `Search results list in the middle`.
  * **Auto-click "Load More":** Check if applicable based on page structure (pagination vs. load more).
  * **Max items to focus:** e.g., `10` (adjust as needed).
  * **In Abnormal Situation:** Keep **Stop Task**.

<img alt="PixPin_2025-12-04_11-40-57.png" />

### 9. [Extract Data Item](/bot/workflow-built/node-types/extract-data-item-node) + Filtering Criteria (Content Filtering: Energy Efficiency Only)

* **Layer 3 Filtering:** Do not rely on the website anymore; perform content filtering during the **Scraping Phase**.
* **Objective:** For the currently focused product card:
  1. Read fields like Product Name and Price.
  2. Only write to the results if the "Product info involves energy efficiency."
* **Configuration:**
  * **Node Type:** **Extract Data Item** (Child of Loop List).
  * **Data Fields:**
    * **Product Name**
    * **Price**
  * **Filtering Criteria:** Check this box.
  * **Description:** `Collect laptops that include Energy efficiency`. (Only collect laptops where the description mentions energy efficiency).
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Effect:** For every item, the AI reads the text. If it matches "Includes Energy efficiency," the Name and Price are saved. If not, it skips the item entirely.

<img alt="PixPin_2025-12-04_11-41-11.png" />

### 10. Configure Output in Start (Export Filtered Results)

* **Objective:** Once traversal is complete, export all products that passed the "Three-Layer Filter."
* **Configuration:**
  * In the **Start** node, set **Default Output Format** to **CSV**.
  * Enable **Convert to file format** when a downloadable file is required.

> **Final Output:** A precise list that has passed Search Box + Category Filter + AI Text Content Filter.

## 3. Human Operation vs. AI Nodes

To better understand the workflow, compare how a human operates versus how the AI nodes are structured.

| **Your Action (Human Operation)** | **Corresponding AI Node** | **Function Description** |
| :- | :- | :- |
| **Think:** "I want a 1TB HDD, Intel CPU laptop, specifically mentioning energy efficiency." | **Start** (Input Parameters) | Abstract conditions into parameters (`hard_drive_size`, `cpu_manufacturer`) for easy reuse. |
| **Open** Amazon homepage. | [**Visit Page**](/bot/workflow-built/node-types/visit-node) | Starts the entire operation. |
| **Type** "Laptop" in top search box and press Enter. | [**Input Text**](/bot/workflow-built/node-types/input-text-node) | **Layer 1 Filter:** Narrow scope from "All Site" to "Laptops." |
| **Scroll down** to find the HDD filter on the left. | [**Scroll to Element**](/bot/workflow-built/node-types/scroll-to-element-node) (HDD Size) | Brings the filter section into view for reliable clicking. |
| **Check** "1 TB" in the HDD section. | [**Click Element**](/bot/workflow-built/node-types/click-element-node) (HDD Option) | **Layer 2 Filter (Part 1):** Use website filter to limit storage capacity. |
| **Scroll down** to find the CPU brand filter. | [**Scroll to Element**](/bot/workflow-built/node-types/scroll-to-element-node) (CPU Brand) | Brings the CPU filter section into view. |
| **Check** "Intel" in the CPU section. | [**Click Element**](/bot/workflow-built/node-types/click-element-node) (CPU Option) | **Layer 2 Filter (Part 2):** Limit CPU brand. |
| **Look** at the filtered results, ready to check one by one. | [**Loop List**](/bot/workflow-built/node-types/loop-list-node) | Treats the middle product cards as a list and iterates through them. |
| **Check each item:** Read description. If it mentions "Energy efficiency," write down Name/Price. Otherwise, skip. | [**Extract Data Item + Filtering Criteria**](/bot/workflow-built/node-types/extract-data-item-node) | **Layer 3 Filter:** AI-based content filtering during scraping. Only saves matching items. |
| **Compile** the final list of matching laptops into a CSV. | **Start output settings** | Returns the multi-dimensionally filtered data in the selected format. |

### Summary

Case 5 demonstrates a classic **"Three-Layer Filtering + Scraping"** workflow:

1. **Search Box:** Narrow scope from full site to a category.
2. **Category Filter:** Use native website filters to tighten conditions.
3. **Content Filter:** Use AI during scraping for the final "Only keep results matching specific text criteria" layer.

Whenever you have a requirement like **"Filter by keyword first, then check categories, and finally only keep a specific subset of matching items,"** you can directly build this workflow.


# Case 2: Auto-Pagination for Multi-Page Lists
Source: https://docs.browseract.com/bot/workflow-built/case-studies/pagination

Learn how to automate data extraction across multiple pages using the Loop node, including auto-pagination and conditional stopping.

## 1. Case Overview

This case demonstrates another high-frequency pattern in web automation: [**Using the Loop node to repeatedly turn pages and collect data in a multi-page list until a specific condition is met.**](/bot/workflow-built/node-types/loop-node)

The core logic is as follows:

1. The AI opens a job listing page.
2. Inside a [**Loop**](/bot/workflow-built/node-types/loop-node), it repeatedly executes: **Collect current page data → Turn to next page → Wait for new page to load**.
3. The Loop automatically decides when to stop based on your settings (e.g., "until 50 job postings are collected").
4. Finally, it exports all job information as structured data.

This case uses the "Customer Service Job List" from a remote work website as an example to demonstrate a complete "Multi-Page List Auto-Pagination + Batch Collection" workflow.

**Note:** This logic is equally applicable to any list page with a pagination bar (e.g., recruitment, e-commerce products, articles, event lists).

<img alt="Gemini_Generated_Image_quo95yquo95yquo9.png" />

## 2. Detailed Steps

### 1. [Visit Page](/bot/workflow-built/node-types/visit-node) (Open Job List)

* **Objective:** Open the target job list page directly, rather than navigating from the homepage.
* **Configuration:**
  * **URL:** Enter the list page address, e.g., `https://himalayas.app/jobs/customer-service`.
  * **Tab:** Select **Current Tab Access**.
  * **In Abnormal Situation:** Keep **Stop Task** (if this step fails, there is no point in continuing).

>

<img alt="PixPin_2025-12-04_11-19-51.png" />

### 2. [Loop](/bot/workflow-built/node-types/loop-node) (Cycle Control: Paginating until 50 items are collected)

* **Objective:** Repeat the entire set of actions "Collect Current Page → Next Page → Wait" until the condition you set is met: **Collect 50 job items** or reach the maximum number of cycles.
* **Configuration:**
  * **Check Timing:** Select **Before each cycle, check the stop condition**.
  * **Stop Condition:** Enter `Until 50 items are collected` in the input box. This means "stop when the number of collected items reaches 50."
  * **Maximum number of cycles:** Enter `100` to limit the loop to a maximum of 100 rounds, preventing infinite loops in extreme cases.
  * **In Abnormal Situation:** Temporarily keep **Stop Task**. If a critical error occurs within the Loop, the task can be terminated immediately.

> **Explanation:** The Loop is the core of this workflow. You are telling the AI: "Run at most 100 laps, but you can stop once you have 50 job items."

<img alt="PixPin_2025-12-04_11-18-57.png" />

### 3. [Extract Data](/bot/workflow-built/node-types/extract-data-node) (Collect Current Page Info)

* **Note:** This node is a **child node** of the Loop, meaning it will execute once in every cycle.
* **Objective:** On the current page, copy information from all visible job cards (e.g., Job Title, Publish Date) and append it to the existing dataset.
* **Configuration:**
  * **Capture the page area range:** Select **Full Page** (convenient for scenarios where the whole page is a list).
  * **Data Field:** List the field names you want to collect, such as:
    * **Job Title**
    * **Publish Date**
  * **Filtering Criteria:** Leave unchecked (do not filter the list yet).
  * **In Abnormal Situation:** Keep **Stop Task**, implying that if data cannot be collected, the task should stop.

> **Note:** Once this step is complete, the "number of collected items" will increase, giving meaning to the Loop condition `Until 50 items are collected`.

<img alt="PixPin_2025-12-04_11-20-45.png" />

### 4. [Pagination](/bot/workflow-built/node-types/pagination-node) (Turn to Next Page)

* **Note:** Also a child node of the Loop. After collecting one page, flip to the next.
* **Objective:** Find the pagination bar at the bottom of the page and click "Next" to enter the next page of the job list.
* **Configuration:**
  * **Next Page / Previous Page:** Select **Next Page**. This tells the Pagination node to specifically handle the "Next" button click.
  * **Element Selection:** Mark the "Next" button or the corresponding pagination element on the page.
  * **In Abnormal Situation:** Keep **Stop Task**.

<img alt="PixPin_2025-12-04_11-20-51.png" />

### 5. [Wait](/bot/workflow-built/node-types/wait-node) (Wait for New Page Load)

* **Objective:** After clicking "Next Page," do not immediately resume collecting. Give the page some time to complete loading.
* **Configuration:**
  * **Wait:** Set to `3` seconds, for example.
  * **Tip:** For environments with unstable networks, consider increasing the wait time.
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Reasoning:** Since the webpage may not load all information immediately, you need to tell the AI: "Wait a moment after turning the page, let the new job cards appear, and then extract."

<img alt="PixPin_2025-12-04_11-20-55.png" />

### 6. Configure Output in Start (Export All Collected Jobs)

* **Objective:** When the Loop determines that "50 job items have been collected" or the maximum cycles are reached, unify and export all data collected from previous pages.
* **Configuration:**
  * In the **Start** node, set **Default Output Format** to **JSON** or **CSV**.
  * Enable **Convert to file format** when a downloadable file is required.

## 3. Human Operation vs. AI Nodes

To better understand the workflow, compare how a human operates versus how the AI nodes are structured. You will see they follow the exact same logic.

| **Your Action (Human Operation)** | **Corresponding AI Node** | **Function Description** |
| :- | :- | :- |
| **Open browser**, enter the job list URL. | [**Visit Page**](/bot/workflow-built/node-types/visit-node) | Starts the task, landing immediately on Page 1 of the list. |
| **Set a goal:** Collect at least 50 jobs, or keep turning pages if not enough. | [**Loop**](/bot/workflow-built/node-types/loop-node) | Sets the cycle rules and stop conditions (e.g., "Until 50 items are collected" or "Max 100 pages"). |
| **Browse** the job cards on the current page, noting down the title and date. | [**Extract Data**](/bot/workflow-built/node-types/extract-data-node) | Batch scrapes fields (Job Title, Publish Date, etc.) from the current page and adds them to the dataset. |
| **Scroll down** to the bottom and click the "Next" button. | [**Pagination**](/bot/workflow-built/node-types/pagination-node) (Next Page) | Automatically clicks the "Next Page" element in the pagination bar to navigate. |
| **Wait** for the new page of jobs to load. | [**Wait**](/bot/workflow-built/node-types/wait-node) | Pauses to allow the page to stabilize and content to appear before the next collection round. |
| **Repeat:** "Record jobs → Click Next → Wait" until total jobs ≥ 50 or the last page is reached. | [**Loop**](/bot/workflow-built/node-types/loop-node) (Execution) | Executes the sequence *Extract Data → Pagination → Wait* repeatedly, checking the stop condition before/after each round. |
| **Organize** all recorded job info into a structured list. | **Start output settings** | Returns all data collected throughout the entire loop process in the selected JSON/CSV format. |

### Summary

Whenever you encounter a **"Multi-Page List"** and your thought process is: "I want to turn pages one by one and copy the first N items," simply build the blocks following this Case 2 structure:

1. **Outer Layer:** Use [**Loop**](/bot/workflow-built/node-types/loop-node) to control "Pagination + Conditional Stop".
2. **Inside Loop:** Place [**Extract Data**](/bot/workflow-built/node-types/extract-data-node) → [**Pagination**](/bot/workflow-built/node-types/pagination-node) → [**Wait**](/bot/workflow-built/node-types/wait-node).
3. **Final Step:** Use the output settings in **Start** to select the result format.


# Click Element Item Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/click-element-item-node

A specific child node for Loop List that clicks a link or button within the currently focused list item.

## Overview

**Click Element Item** is a child node used inside **Loop List**. It clicks a specific element within the current list item, such as a title link, product image, or **View Details** button.

<img alt="Gemini_Generated_Image_grr7ozgrr7ozgrr7.png" />

## Use Cases

* Open each video from a video list and collect information from its detail page.
* Open each news headline and extract the full article content.
* Open each product title or image and collect specifications or reviews.

## Core Capabilities

* Identify a click target within the current list item using natural language.
* Open a detail page or expand content associated with the current item.
* Continue with [**Extract Data**](/bot/workflow-built/node-types/extract-data-node) or another action after the click.

## Configuration Steps

1. Add a [**Click Element Item**](/bot/workflow-built/node-types/click-element-item-node) node inside a [**Loop List**](/bot/workflow-built/node-types/loop-list-node).
2. Describe the element to click in **Element Description**, for example:
   * "Click the title link of the current job item"
   * "Click the thumbnail of the current video item"
   * "Click the View Details button in the current product item"
3. Add [**Extract Data**](/bot/workflow-built/node-types/extract-data-node) or another node after the click to continue processing the current item.

<img alt="PixPin_2025-12-04_14-13-52.png" />

## Recommendations

* Use **Click Element Item** only inside **Loop List**.
* Each node performs one click. Add another node when the current item requires another click.
* Include "current item" and the visible label or element type in the description.
* When the list page must remain available, open or manage the detail page with the appropriate **Tab Operation** flow.


# Click Element Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/click-element-node

Click a visible button, link, icon, or other element described in natural language.

# Click Element

Use **Click Element** to click a visible element on the current page. Describe the target in natural language; no selector or code is required.

## What Is the Click Element Node?

The node identifies and clicks the element that matches your description. It can be used with buttons, links, icons, checkboxes, radio buttons, and other interactive elements.

<img alt="Click Element node overview" />

### Click Type Options

| Click type | Description | Default |
| - | - | - |
| Left-click | Standard click for buttons, links, forms, and most page actions. | Yes |
| Right-click | Opens a context menu or triggers a website's right-click action. | No |

## When Should You Use It?

Use **Left-click** to:

* Submit a form or start a search.
* Open a menu, link, or another page.
* Select a checkbox, radio button, or visible option.
* Load more results or move to the next step.

Use **Right-click** when the required action is exposed through a context menu or right-click event.

## How to Set Up a Click Element Node

### 1. Insert the Node

Select the `+` below a node, then choose **Click Element** from the Node Action Library.

### 2. Describe the Target Element

Describe the element using its visible text, type, location, or other distinguishing details.

Examples:

```text theme={null}
The Search button to the right of the search field
```

```text theme={null}
The blue Continue button at the bottom of the form
```

### 3. Select the Click Type

Choose **Left-click** for a standard interaction or **Right-click** for a context-menu action.

### 4. Handle Errors

Configure the failure behavior when the target cannot be found or clicked.

### 5. Connect Other Nodes

Place the node after the page-opening or navigation step. Add a **Wait**, extraction, or another interaction node after it as required by the page.

## Key Rules and Best Practices

### Rules

| Rule | Description |
| - | - |
| Target must be available | The target element must be present and visible when the node runs. |
| One click per node | Add another Click Element node for each additional click. |
| Describe the target clearly | Use visible text and distinguishing details instead of a vague label. |
| Click type is explicit | Select the click type that matches the website interaction. |

### Best Practices

* Include the element type, such as button, link, icon, or checkbox.
* Include visible text and location when similar elements appear more than once.
* Use **Scroll to Element** when the target is farther down the page.
* Use **Wait** when the click loads new content or navigates to another page.
* Test the workflow to confirm that the intended element is clicked.

## Quick Review

1. **What does Click Element do?**\
   It clicks the visible element that matches the natural-language description.

2. **How many clicks does one node perform?**\
   One click per node.

3. **When should Right-click be used?**\
   When the website exposes the required action through a context menu or right-click event.

4. **What makes a good target description?**\
   Visible text, element type, location, and other distinguishing details.

## Next Steps

Combine **Click Element** with **Wait**, **Scroll to Element**, **Input Text**, or data extraction nodes to continue the workflow after the click.

## Need Help?

* Join the [BrowserAct Discord community](https://discord.com/invite/UpnCKd7GaU).
* Email [support@browseract.com](mailto:support@browseract.com).


# Condition Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/condition-node

Creates logical branches (True/False) to direct the workflow based on page content or variables.

Overview

The Condition node performs "branch logic" within a workflow. Based on the current page state or outputs from previous nodes, it decides which subsequent path to execute, enabling intelligent workflow branching.

<img alt="Gemini_Generated_Image_pzn4dmpzn4dmpzn4.png" />

**Use Cases**

* Checking if a user is logged in (e.g., does a "Sign out" button exist on the page?).
* Checking if there is a next page (e.g., is the "Next Page" button clickable?).
* Checking stock status (does the page display "Out of Stock" or "Sold Out"?).
* Handling pop-ups or ad overlays (checking if specific pop-up elements appear).

**Core Capabilities**

* Uses natural language to describe conditions.
* Provides default **True / False** branches, which can connect to any nodes.
* Supports multi-dimensional judgment based on visible page content, URL, variables, preceding node outputs, etc.

**Configuration Steps**

1. Add a **Condition** node.
2. Use natural language in the condition description, for example:
   * "Does the current page display the text 'Out of Stock'?"
   * "Does a 'View All Jobs' button exist?"
   * "Does the current URL contain '/checkout'?"
3. Configure the **True** branch: The chain of nodes to execute when the condition is met.
4. Configure the **False** branch: The chain of nodes to execute when the condition is not met.
5. At runtime, the system automatically evaluates the condition and follows the corresponding branch.

<img alt="PixPin_2025-12-04_14-56-17.png" />

**Recommendations**

* Be as specific as possible when describing conditions. Avoid vague phrases like "Check the button."
* Condition nodes support nesting up to 3 levels; be mindful of branch complexity and maintainability.
* If two branches eventually perform the same behavior, both True and False branches can point to the same subsequent node.
* For very complex logic, split into multiple serial Condition nodes to implement multi-step judgment.


# Extract Data Item Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/extract-data-item-node

A specific child node for Loop List that captures data fields from the currently focused list item.

Overview

Extract Data Item is a specialized child node designed for use inside a [Loop List](/bot/workflow-built/node-types/loop-list-node). It extracts specified fields from the currently focused single list item and compiles these fields into structured data.

<img alt="Gemini_Generated_Image_nix1gonix1gonix1.png" />

**Use Cases**

* Extracting "Name, Price, Image, Rating" fields for each product in a product list.
* Extracting "Title, Summary, Date, Likes" information in a post list.
* Extracting "Job Title, Company, Location, Salary Range" in a job list.

**Core Capabilities**

* Batch extracts multiple fields from the current list item.
* Supports filling unified placeholder values (e.g., None) for missing fields.
* Supports filtering criteria configuration to keep only data meeting specific conditions (e.g., posted within the last N days).

**Configuration Steps**

1. Add an **Extract Data Item** node inside a [**Loop List**](/bot/workflow-built/node-types/loop-list-node).
2. Configure **Data Fields** prompts to clearly describe the fields to extract, for example:
   * "Extract from current job item: Job Title, Company Name, Post Date, Salary Range. If missing, fill N/A."
3. (Optional) Configure **Filtering Criteria**, for example:
   * "Only keep jobs posted within the last 3 days."
4. Upon execution, Loop List runs Extract Data Item for each list item and aggregates the data into a table/dataset.

<img alt="PixPin_2025-12-04_14-17-10.png" />

**Recommendations**

* It is best to configure only one Extract Data Item node per Loop List to maintain a clear structure.
* Clearer field descriptions lead to more stable extraction results; state field names and meanings clearly.
* If the page structure is complex, consider splitting into multiple [Loop List](/bot/workflow-built/node-types/loop-list-node) + Extract Data Item sets to extract by region.


# Extract Data Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/extract-data-node

Scrapes structured data from the full page or the current visible area (independent of list loops).

Overview

The Extract Data node is used to extract structured data from the entire page or the current visible area. It is a general-purpose page data collection tool. Unlike Extract Data Item, it does not rely on Loop List and can be used independently.

<img alt="Gemini_Generated_Image_y72nxxy72nxxy72n.png" />

**Use Cases**

* Extracting all matching data from a full page at once (e.g., comment lists, article lists, product info).
* Extracting a set of fields from a detail page (e.g., multiple specification fields on a product detail page).
* Accumulating data from multiple pages when combined with [Pagination](/bot/workflow-built/node-types/pagination-node) inside a [Loop](/bot/workflow-built/node-types/loop-node).

**Core Capabilities**

* Supports two extraction scopes: **Full Page** or **Visible Area**.
* Uses natural language to describe fields and positions to extract.
* Supports filtering conditions (filter by time, quantity, attributes, etc.).
* Returns structured data in the default output format configured in the **Start** node.

**Configuration Steps**

1. Add an **Extract Data** node.
2. Select extraction scope:
   * **Full Page:** Collect data from the entire page.
   * **Visible Area:** Collect data only from the current viewport.
3. Clearly specify content to extract in the field description. For example:
   * "Extract from product detail page: Product Name, Current Price, Original Price, Stock Status, Rating, Review Count, Seller Name, Shipping Info."
4. (Optional) Configure filtering criteria, for example:
   * "Only keep reviews from the last 30 days."
   * "Only extract products with a price greater than 100."
5. For cross-page extraction, place Extract Data inside a [Loop](/bot/workflow-built/node-types/loop-node) or combine with [Pagination](/bot/workflow-built/node-types/pagination-node).

<img alt="PixPin_2025-12-04_14-18-10.png" />

**Recommendations**

* For scenarios with complex page structures, consider using multiple Extract Data nodes to process different areas separately.
* Each Extract Data node executes extraction only once. For multi-page extraction, combine with [Loop](/bot/workflow-built/node-types/loop-node) + [Pagination](/bot/workflow-built/node-types/pagination-node).
* Consider adding a [**Wait**](/bot/workflow-built/node-types/wait-node) node before extraction to ensure dynamic content has loaded.
* Field descriptions should be detailed, including field names and meanings, to facilitate subsequent use and maintenance.


# Hover Element Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/hover-element-node

Move the pointer over a visible element to reveal or trigger hover-based content.

# Hover Element

Use **Hover Element** to move the pointer over a visible element described in natural language. This is useful for menus, tooltips, preview cards, and actions that appear only on hover.

## What Is the Hover Element Node?

The node identifies the visible element that matches your description and triggers its hover state. No selector or code is required.

## When Should You Use It?

Use **Hover Element** to:

* Reveal a dropdown or navigation submenu.
* Display a tooltip before extracting its content.
* Open a profile, product, or link preview card.
* Access an e-commerce mega menu.
* Reveal action buttons that appear only when the pointer is over an item.

## How to Set Up a Hover Element Node

### 1. Insert the Node

Select the `+` below a node, then choose **Hover Element** from the Node Action Library.

### 2. Describe the Target Element

In **Element Location Description**, describe the element using its visible text, type, location, or position.

Correct examples:

* `The Products menu item in the top navigation bar`
* `The user avatar icon in the upper-right corner`
* `The first product card in the search results`
* `The More options icon next to the file name`
* `The category menu in the sidebar`

Avoid describing multiple actions in one node. For example, hovering over a menu and clicking an option require separate **Hover Element** and **Click Element** nodes.

### 3. Handle Errors

Configure the failure behavior when the target element cannot be found.

### 4. Connect Other Nodes

Place **Hover Element** after the page-opening or navigation step. It is commonly followed by:

* **Click Element** to click a revealed menu option.
* **Extract Data** to capture tooltip or hover-card content.
* **Wait** when the hover effect needs time to appear.

## Examples

### Reveal a Dropdown Menu

**Goal:** Hover over a navigation item to reveal its dropdown, then click an option.

**Step 1: Add Visit Page**

* URL: `https://www.amazon.com/`
* Access method: **Current Tab Access**
* Failure behavior: **Stop Task**

**Step 2: Add Hover Element**

* Element description: `The Gift Cards menu item in the top navigation bar`
* Failure behavior: **Stop Task**

**Step 3: Add Click Element**

* Element description: `The Shop all gift cards option in the dropdown menu`
* Click type: **Left-click**
* Failure behavior: **Stop Task**

## Key Rules and Best Practices

### Rules

| Rule | Description |
| - | - |
| Target must be visible | The node can interact only with an element that is visible when it runs. |
| One hover per node | Each node performs one hover action. |
| Describe the target clearly | Use visible text, element type, location, or position. |
| Hover state is temporary | The state may end when the next action moves the pointer or changes the page. |

### Element Description Tips

* Include the element type, such as menu item, icon, button, card, or row.
* Specify a location, such as the top navigation bar, sidebar, or first row.
* Include visible text or another distinguishing detail.
* Use position references such as first, second, or next to.

### Workflow Tips

| Scenario | Recommended flow |
| - | - |
| Dropdown menu | Hover Element -> Click Element |
| Tooltip extraction | Hover Element -> Wait -> Extract Data |
| Mega menu | Hover Element -> Wait -> Click Element |
| Hidden action button | Hover Element -> Click Element |

## Quick Review

1. **What does Hover Element do?**\
   It moves the pointer over a visible element and triggers its hover state.

2. **Can it target an element outside the visible area?**\
   No. Scroll to the target first.

3. **How many hover actions does one node perform?**\
   One.

4. **What commonly follows Hover Element?**\
   **Click Element**, **Extract Data**, or **Wait**.

5. **How long does the hover state remain active?**\
   It may remain until another action moves the pointer or changes the page.

## Next Steps

Combine **Hover Element** with **Click Element**, **Wait**, and **Extract Data** for interfaces that reveal content or controls on hover.

## Need Help?

* Join the [BrowserAct Discord community](https://discord.com/invite/UpnCKd7GaU).
* Email [support@browseract.com](mailto:support@browseract.com).


# Human Interaction Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/human-interaction-node

Pauses the workflow and hands browser control to a human, then resumes automation after manual actions are completed.

Overview

The Human Interaction node is used when part of a workflow cannot be fully automated and requires human judgment or manual input. When the workflow reaches this node, browser control is temporarily handed over to a human; after the user completes the required actions and confirms, the workflow resumes automatically.

**Video Tutorial**

[![Watch Handle Complex Login with the Human Interaction Node](https://i.ytimg.com/vi/KkJaE4S_Sx0/hqdefault.jpg)](https://www.youtube.com/watch?v=KkJaE4S_Sx0)

[Watch **Handle Complex Login with the Human Interaction Node** on YouTube](https://www.youtube.com/watch?v=KkJaE4S_Sx0).

<img alt="Gemini_Generated_Image_9kiorn9kiorn9kio.png" />

**Use Cases**

* Completing login flows that require username, password, and verification codes (e.g., email/SMS OTP).
* Handling captcha-protected pages that must be solved by a human.
* Manually reviewing content or making a decision before continuing (e.g., approve/reject, choose a category).
* Performing sensitive or high-risk operations that should not be fully automated.

**Core Capabilities**

* Pauses the workflow and temporarily transfers browser control to a human operator.
* Supports multiple notification options: in-app notification and optional email notification.
* Allows execution either inside the BrowserAct interface or via a standalone web interface opened from email.
* Automatically resumes the workflow once the human step is completed and confirmed.
* Supports a configurable time limit for how long the workflow waits for human intervention.

**Configuration Steps**

1. Add a **Human Interaction** node to the workflow.
2. In **Instruction for human**, clearly describe what the human should do on the page. For example:
   * "Please enter your username, password, and verification code to complete the login process."
   * "Please solve the captcha and ensure the page successfully loads the dashboard."
3. Set **Time Limit** to define how long the workflow should wait for human intervention. When the time limit expires, this step ends immediately according to your workflow design.
4. Configure **Notify when this step starts**:
   * **Checked:** Enter a valid email address. An email notification will be sent, and the recipient can open a standalone web interface to perform the task—useful when the operator is away from the main console.
   * **Unchecked:** The human performs all actions directly inside the BrowserAct interface without email notification.
5. When execution reaches the Human Interaction node, the operator follows the instructions, completes the required actions in the browser, and clicks **Resume** to continue the workflow.

<img alt="PixPin_2025-12-05_21-11-08.png" />

**Recommendations**

* Keep instructions short, specific, and action-oriented so the human knows exactly what to do.
* Choose a reasonable time limit based on how long the manual step typically takes.
* Use email notifications when the operator may not be in front of the BrowserAct interface.
* Place Human Interaction nodes only at steps that truly require manual actions to avoid unnecessary interruptions.


# Overview
Source: https://docs.browseract.com/bot/workflow-built/node-types/index



Workflow Built Bots are assembled from nodes. Each node performs one operation in the workflow.

## Navigation and Page Control

* Visit Page
* Tab Operation
* Scroll Page
* Scroll to Element
* Pagination
* Wait

## Page Interaction

* Click Element
* Click Element Item
* Input Text
* Hover Element
* Human Interaction

## Data Extraction and Output

* Extract Data
* Extract Data Item Node
* Start

## Logic and Repetition

* Condition
* Loop
* Loop List

Open an individual node page to review its settings, expected inputs, and usage examples.


# Input Text Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/input-text-node

Automatically types text or variables into input fields, such as search bars or forms.

## Overview

The **Input Text** node enters text into a web input field, such as a search box, form field, or message box.

<img alt="Gemini_Generated_Image_7lk8kz7lk8kz7lk8.png" />

## Use Cases

* Enter a keyword in a search box, then start the search with [**Click Element**](/bot/workflow-built/node-types/click-element-node).
* Fill in a form, login field, or contact field.
* Enter text in a comment box or message field.
* Use parameters to enter different values across runs or loop items.

## Core Capabilities

* Identify an input field from a natural-language description.
* Clear its existing value and enter the specified text.
* Reference an input parameter or a value from an earlier node.

## Configuration Steps

1. Add an **Input Text** node.
2. Configure **Input Box Description**, for example:
   * "The search box at the top of the page"
   * "The email address input field in the registration form"
   * "The message input box in the bottom right corner of the page"
3. Configure **Text Content**:
   * Directly enter fixed text (e.g., `customer service`).
   * Enter `/` to reference parameters, such as `{{product_name}}` or `{{user_email}}`.
4. When the node runs, it will:
   * Locate the described input box.
   * Clear original content.
   * Enter the specified text and proceed to the next step.

<img alt="PixPin_2025-12-04_14-14-04.png" />

## Recommendations

* Each Input Text node is responsible for one input field. Use multiple nodes for multiple fields.
* If the field is not visible, use **Scroll Page** or **Scroll to Element** first.
* Use parameter references for values that change between runs or loop items.
* If the page or form loads slowly, add [**Wait**](/bot/workflow-built/node-types/wait-node) before **Input Text**.


# Loop List Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/loop-list-node

Iterates through a specific list area on the page to process items (extract data or click) one by one.

**Overview**

The Loop List node is used to iterate through every item in a specific "list area" on a page (e.g., job lists, product lists, post lists) and perform child operations (extract, click, etc.) on each item.

**Video Tutorial**

[![Watch How to Scrape Deep Nested Data with Loop List](https://i.ytimg.com/vi/tarseJbeSII/hqdefault.jpg)](https://www.youtube.com/watch?v=tarseJbeSII)

[Watch **How to Scrape Deep Nested Data with Loop List** on YouTube](https://www.youtube.com/watch?v=tarseJbeSII).

<img alt="Gemini_Generated_Image_gayqrfgayqrfgayq.png" />

**Use Cases**

* Batch extracting data from Reddit posts, product cards, job cards, etc.
* Entering the detail page of each item in a list to collect more detailed information.
* Performing the same operation (click, scroll, scrape) on every element in a list.

**Core Capabilities**

* Locates list regions via natural language description.
* Supports setting a maximum number of loop items (**Max Focused Loop Items**).
* Supports a **Load More** option for lists requiring expansion.
* Supports up to 3 levels of nested Loop Lists for complex multi-level lists.

**Configuration Steps**

1. Add a **Loop List** node.
2. Configure basic settings:
   * **List Region Description:** Describe where the list is located, e.g., "The job list area in the middle of the page."
   * **Load More:**
     * Check: If the list requires clicking "Load More" or uses pagination.
     * Uncheck: If the list auto-loads or only the current page is needed.
   * **Max Focused Loop Items:** Maximum number of items to process (e.g., 10, 20, 50), set according to business needs.
3. Add child nodes inside the Loop List:
   * [**Extract Data Item**](/bot/workflow-built/node-types/extract-data-item-node)**:** Extract fields from the current list item.
   * [**Click Element Item**](/bot/workflow-built/node-types/click-element-item-node)**:** Click a button or link within the current list item.

<img alt="PixPin_2025-12-04_14-22-01.png" />

**Recommendations**

* Only one Loop List node is allowed per hierarchy level; maximum 3 levels of nesting.
* Loop List requires at least one child node ([**Extract Data Item**](/bot/workflow-built/node-types/extract-data-item-node) or [**Click Element Item**](/bot/workflow-built/node-types/click-element-item-node)).
* Setting **Max Focused Loop Items** too high may result in excessive execution time; match it to actual requirements.
* For infinite scroll lists, combine with [**Scroll**](/bot/workflow-built/node-types/scroll-page-node) nodes and the "Load More" option.

***

**Related Video**

<iframe title="YouTube video player" />


# Loop Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/loop-node

Repeats a sequence of actions (like pagination or scrolling) until a specific condition is met.

**Overview**

The Loop node is a general-purpose cycle engine used to repeat a specific process flow until an exit condition is met. Unlike Loop List (which iterates through list items), Loop is better suited for repeating "cross-page or cross-action" tasks, such as turning pages or scrolling + extracting.

**Video Tutorial**

[![Watch Loop vs Loop List for Data Extraction](https://i.ytimg.com/vi/w0_hMrUztXY/hqdefault.jpg)](https://www.youtube.com/watch?v=w0_hMrUztXY)

[Watch **Loop vs Loop List for Data Extraction** on YouTube](https://www.youtube.com/watch?v=w0_hMrUztXY).

<img alt="Gemini_Generated_Image_7jw8xh7jw8xh7jw8.png" />

**Use Cases**

* Repeating "[Pagination](/bot/workflow-built/node-types/pagination-node) + [Extraction](/bot/workflow-built/node-types/extract-data-node)" operations across multiple pages until a target data count is reached.
* Looping "[Scroll](/bot/workflow-built/node-types/scroll-page-node) + [Extraction](/bot/workflow-built/node-types/extract-data-node)" on infinite scroll pages until "No more data" appears.
* Repeatedly clicking a "Load More" button until specific text appears or a condition is met.

**Core Capabilities**

* Supports natural language descriptions for exit conditions (e.g., "Until 50 items are collected").
* Supports setting a maximum iteration count (default 10, max 999) to prevent infinite loops.
* Supports selecting condition check timing (Before Loop / After Loop).
* Supports choosing "Stop Task" or "Skip Current Loop" on errors.

**Configuration Steps**

1. Add a **Loop** node.
2. Configure the exit condition description, for example:
   * "Until the collected product count reaches item\_limit"
   * "Stop when the text 'No more results' appears at the bottom of the page"
3. Set **Max Iterations** (e.g., 10, 20) as a safety cap.
4. Select check timing:
   * **Before Loop:** Check condition before execution; if met, the loop body is not executed.
   * **After Loop:** Execute the loop at least once, then check if it should continue.
5. Add child nodes inside the Loop (such as Scroll, Extract Data, Pagination, etc.) to form the loop body.

<img alt="PixPin_2025-12-04_14-23-11.png" />

**Recommendations**

* Prioritize clear, determinable exit conditions. Avoid vague descriptions like "Until all data is scraped."
* During development and debugging, set specific Max Iterations low (e.g., 2) to test workflow correctness before scaling up.
* Loop is oriented towards controlling "action-level repetition," whereas item-by-item processing is better handled by [**Loop List**](/bot/workflow-built/node-types/loop-list-node).

***

**Related Video**

<iframe title="YouTube video player" />


# Pagination Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/pagination-node

Handles navigation for multi-page content by automatically clicking 'Next' or 'Previous' buttons.

Overview

The Pagination node is used to automatically turn pages in multi-page content, such as clicking "Next Page" or "Previous Page" buttons. It works with [extraction](/bot/workflow-built/node-types/extract-data-node) nodes to implement batch collection across multiple pages.

<img alt="Gemini_Generated_Image_tj4an5tj4an5tj4a.png" />

**Use Cases**

* Multi-page search results or product lists on e-commerce sites.
* Multi-page job lists on recruitment sites.
* Paginated archive lists on news sites or forums.

**Core Capabilities**

* Supports **Next Page** or **Previous Page** navigation.
* Can generate multi-page loops when combined with [Extract Data](/bot/workflow-built/node-types/extract-data-node), [Loop List](/bot/workflow-built/node-types/loop-list-node), Loop, and [Scroll](/bot/workflow-built/node-types/scroll-page-node) nodes.
* Option to terminate the task or skip and continue upon pagination failure.

**Configuration Steps**

1. Add a **Pagination** node.
2. Select the direction in **Direction**:
   * **Next Page**
   * **Previous Page**
3. Configure error handling strategy:
   * **Stop Task:** Terminate the workflow if pagination fails (e.g., reached the last page).
   * **Skip and Continue:** Ignore the current pagination error and proceed to subsequent nodes.
4. Usually place Pagination after [**Extract Data**](/bot/workflow-built/node-types/extract-data-node) to ensure current page data is collected before turning the page.

<img alt="PixPin_2025-12-04_14-26-18.png" />

**Recommendations**

* Each Pagination node executes only one page turn action. For batch pagination, combine with **Loop** / **Loop List**.
* If the pagination button is not in the current visible area, use **Scroll Page** or **Scroll to Element** first to scroll to the pagination area.
* For scenarios with an uncertain number of pages, recommend using **Loop** with "Data count/Button status" as the exit condition.


# Scroll Page Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/scroll-page-node

Performs basic page-level scrolling actions, such as scrolling down one screen or jumping to the bottom.

Overview

The Scroll Page node performs simple overall scrolling actions on the page, such as scrolling down one screen, scrolling to the top, or scrolling to the bottom, to load more content or reveal hidden areas.

<img alt="Gemini_Generated_Image_cmlz5mcmlz5mcmlz.png" />

**Use Cases**

* Scrolling down on long list pages to load more items.
* Scrolling to the bottom of the page to view the footer or pagination area.
* Specifying a particular area to scroll within pages that have multiple scrollable regions.

**Core Capabilities**

* Supports four basic scrolling methods:
  * Scroll down one screen
  * Scroll up one screen
  * Scroll to top page
  * Scroll to bottom page
* Supports identifying multiple scrollable areas (e.g., main content area, sidebar, etc.).

**Configuration Steps**

1. Add a **Scroll Page** node.
2. Select the scrolling direction:
   * **Scroll down one screen**
   * **Scroll up one screen**
   * **Scroll to top page**
   * **Scroll to bottom page**
3. If the page has multiple scrollable areas:
   * Check **Page has multiple scrollable areas**.
   * Specify the area in the description, such as: "Main content area", "Left sidebar", or "Comment section".
4. At runtime, the node executes one scroll action and proceeds to the next step.

<img alt="PixPin_2025-12-04_14-32-32.png" />

**Recommendations**

* Scroll Page scrolls only once per execution. Combine with a [**Loop**](/bot/workflow-built/node-types/loop-node) node for continuous scrolling.
* For pages using "Scroll down to load more," you can loop: \*\*Scroll Page → \*\*[**Extract Data**](/bot/workflow-built/node-types/extract-data-node).
* If the goal is to scroll to a specific area (e.g., comments section), consider using the [**Scroll to Element**](/bot/workflow-built/node-types/scroll-to-element-node) node instead.


# Scroll to Element Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/scroll-to-element-node

Continuously scrolls the page until a specific target area or element becomes visible in the viewport.

Overview

The Scroll to Element node automatically scrolls the page until a target area or element appears in the viewport. It is suitable for scenarios where you "know where to go, but don't know how much to scroll."

<img alt="Gemini_Generated_Image_a81dxwa81dxwa81d.png" />

**Use Cases**

* Scrolling to the comment section on YouTube, Instagram, or forums.
* Scrolling to a specific "Job List Area" or "Product Review Area" in the middle of a page.
* Scrolling to specific areas like "Form Bottom" or "Footer Subscription Area" on long pages.

**Core Capabilities**

* Locates target areas based on natural language descriptions.
* Automatically scrolls up to approximately 10 screens until the element appears in the visible area.
* Supports target area selection on pages with multiple scrollable regions.

**Configuration Steps**

1. Add a **Scroll to Element** node.
2. Describe the target element/area in the description field, for example:
   * "Comment section"
   * "The job list area in the middle of the page"
   * "The newsletter subscription form at the bottom"
3. If the page has multiple scrollable areas:
   * Check **Page has multiple scrollable areas**.
   * Describe the specific area to scroll (e.g., "Main content area", "Comment area").
4. Configure the maximum scroll attempts (default is roughly 10 screens).
5. At runtime, the node scrolls screen by screen until the target area is located, then executes subsequent nodes.

<img alt="PixPin_2025-12-04_14-33-56.png" />

**Recommendations**

* Descriptions should target the "Area" rather than an action, for example:
  * ✅ "Scroll to the comment section"
  * ❌ "Scroll down until you see the button"
* If you need to click or extract data after scrolling, place [**Click Element**](/bot/workflow-built/node-types/click-element-node) / [**Extract Data**](/bot/workflow-built/node-types/extract-data-node) after this node.
* For complex page structures, verify the relative position of the area in a browser before writing the description.

***


# Start Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/start-node

Configure the Bot inputs, login behavior, browser, proxy region, and default output format.

Overview

The Start node defines the settings used when the Workflow Built Bot runs. Every workflow begins with one Start node.

<img alt="Configure input parameters, credentials, browser settings, and output format in the Start node" />

**Use Cases**

* Defining input parameters that users provide before a run.
* Configuring credential prompts or stored credentials.
* Selecting the default browser mode and proxy region.
* Selecting the default result format.
* Converting the structured result to a downloadable file.

**Core Capabilities**

* Defines the workflow input parameters.
* Configures supported website auto-login options.
* Sets the default browser mode and proxy region.
* Sets the default output format for the workflow result.
* Supports converting the result to a file format.

**Configuration Steps**

1. Open the **Start** node at the beginning of the workflow.
2. Add the input parameters required for each run.
3. Configure website auto-login when the workflow requires an authenticated page.
4. Select the default browser mode and proxy region.
5. Select the **Default Output Format**.
6. Enable **Convert to file format** when the result should be returned as a downloadable file.

**Recommendations**

* Use clear input parameter names and descriptions.
* Select the browser mode and proxy region that match the target website.
* Use JSON for API and automation integrations, or CSV for spreadsheet use.
* Test the output before publishing to confirm that all required extraction fields are returned.


# Tab Operation Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/tab-operation-node

Manages browser tab history and state, performing actions like Go Back or Close Tab.

Overview

The Tab Operation node manages browser tabs within an automation process, such as closing the current tab or navigating back to the previous page. This helps keep the browsing context clean and controllable in multi-page, multi-step scenarios.

Note: Current document

ation primarily covers Close Tab and Go Back operations.

<img alt="Gemini_Generated_Image_wjp8onwjp8onwjp8.png" />

**Use Cases**

* After entering multiple detail pages from a list page, closing the detail page upon completion to return to the list page for further processing.
* After clicking multiple links in the same tab, needing to go back to the previous page to continue the flow.
* Performing session cleanup in complex workflows to avoid opening too many tabs.

**Core Capabilities**

* **Close Tab:** Closes the current tab (if it is the only tab remaining, it jumps to a blank page).
* **Go Back:** Navigates back to the previous page in the browsing history within the current tab.
* Supports error handling: Select Stop or Skip if history is empty or the tab is unavailable.

**Configuration Steps**

1. Add a **Tab Operation** node and select the required operation type:
   * **Close Tab**
   * **Go Back**
2. Briefly describe the operation purpose (optional), for example:
   * "Close current detail page"
   * "Return to the job list on the previous page"
3. Configure error handling method:
   * **Stop Task:** Terminate the task when the operation cannot be executed (e.g., no history to go back to).
   * **Skip:** Ignore the error and continue executing subsequent nodes.

<img alt="PixPin_2025-12-04_14-35-25.png" />

**Recommendations**

* In [**Loop List**](/bot/workflow-built/node-types/loop-list-node)\*\* + \*\*[**Click Element Item**](/bot/workflow-built/node-types/click-element-item-node) scenarios, a common pattern is:
  * List Click → Detail Page Extraction → **Go Back / Close Tab** → Continue to next item.
* If using multi-tab mode (Visit Page selects New Tab), use Close Tab to close specific tabs after processing to remove clutter.
* Note that Tab Operation actions only affect tabs within the current session; they do not affect other browser windows on the user's local machine.


# Visit Page Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/visit-node

Open a specific URL in the current tab or a new tab.

# Visit Page

## Overview

The **Visit Page** node opens a target webpage in the browser. It is commonly placed after the **Start** node and before clicks, text input, scrolling, or data extraction.

<img alt="Add a Visit Page node from the Node Action Library" />

## Use Cases

* Open a product list, search result, forum, or other target page.
* Start a monitoring or data extraction workflow from a fixed URL.
* Open a URL supplied through a Bot input or an earlier node.
* Open a page in a new tab while keeping the current page available.

## Core Capabilities

* Open a complete URL in the current tab or a new tab.
* Reference an input parameter or a value from an earlier node.
* Configure how the workflow responds if the page cannot be opened.

## Configuration Steps

1. Select the `+` below a node and choose **Visit Page**.
2. Enter a complete URL beginning with `http://` or `https://`.
3. Select **Current Tab Access** or **New Tab Execution**.
4. Configure the failure behavior when needed.

<img alt="Configure the URL and tab behavior in a Visit Page node" />

Example:

```text theme={null}
https://www.google.com/maps
```

### Use a Dynamic URL

The URL can reference an input parameter or a value produced by an earlier node. Use a dynamic URL when the destination changes between runs or while processing a list of URLs.

<img alt="Use an input parameter as the Visit Page URL" />

For multiple URLs, place **Visit Page** inside the appropriate **Loop** or **Loop List** flow.

## Recommendations

* Use one **Visit Page** node for each page-opening action.
* Use a direct URL when the workflow always starts from the same page.
* Open a new tab when the original page must remain available.
* Add interaction or extraction nodes after the page has loaded.
* Test the workflow before publishing the Bot.


# Wait Node
Source: https://docs.browseract.com/bot/workflow-built/node-types/wait-node

Pauses the workflow for a specified number of seconds to allow dynamic content to finish loading.

Overview

The Wait node inserts a "waiting period" into the workflow to ensure pages or dynamic content have finished loading before subsequent operations are executed, preventing clicks or extractions from failing due to slow loading.

<img alt="Gemini_Generated_Image_lzbih0lzbih0lzbi.png" />

**Use Cases**

* Waiting for content to load after clicking "Load More" or "View More Comments."
* Waiting for a new page to render after switching pages or submitting forms.
* Pages with heavy JavaScript or significant network latency.

**Core Capabilities**

* Pauses the workflow for a specified number of seconds (e.g., 3s, 5s, 10s).
* Can be used as a pacing tool between any nodes.

**Configuration Steps**

1. Add a **Wait** node.
2. Enter the number of seconds in **Wait Time**, for example:
   * **3 seconds:** Fast-loading pages.
   * **5 seconds:** General dynamic pages.
   * **10 seconds:** Complex or slow pages.
3. At runtime, the workflow pauses at this node for the corresponding duration, then proceeds to the next node.

<img alt="Set a fixed wait time in seconds" />

**Recommendations**

* Recommended for use after nodes that trigger page changes, such as [**Click Element**](/bot/workflow-built/node-types/click-element-node), [**Visit Page**](/bot/workflow-built/node-types/visit-node), [**Pagination**](/bot/workflow-built/node-types/pagination-node), or [**Scroll**](/bot/workflow-built/node-types/scroll-page-node).
* Wait times should be "sufficient but not excessive"; optimize through testing.
* For pages that load in stages, use multiple shorter Wait nodes after key actions instead of one long wait.
* **Note:** Wait cannot replace element detection logic; it is merely a time compensation measure.


# Overview
Source: https://docs.browseract.com/bot/workflow-built/overview



Workflow Built lets you create a Bot by connecting and configuring nodes in a visual builder. Each node represents a browser action, condition, data operation, or output step.

Use Workflow Built when you know the steps the browser should follow and want direct control over the order, conditions, loops, and extracted fields.

## How Workflow Built Works

### 1. Open the Workflow Builder

Select `Create`, find `Build with Workflow`, and select `Open editor`.

<img alt="Open Build with Workflow from the Create menu" />

### 2. Create the Workflow

Enter an `AI Workflow Name`, add an optional description, and select `Create`.

<img alt="Name and create the Workflow Built Bot" />

### 3. Configure the Start Node

Use the Start node to configure the settings the Bot needs before its first action:

* Input parameters
* Supported website credentials or login prompts
* Default browser mode and proxy region
* Default output format

### 4. Add and Configure Nodes

Select the `+` below a node to open the Node Action Library. Add the browser actions, data operations, conditions, loops, and output nodes required for the task.

<img alt="Add a node from the Node Action Library" />

Connect the nodes in execution order and configure each node before testing the Bot.

## Mapping Manual Actions to Nodes

To automate a web task, map each manual browser interaction to a BrowserAct node:

| Manual interaction | BrowserAct node |
| - | - |
| Open a URL | [**Visit Page**](./node-types/visit-node.mdx) |
| Type text into a field | [**Input Text**](./node-types/input-text-node.mdx) |
| Click a button or link | [**Click Element**](./node-types/click-element-node.mdx) |
| Scroll the viewport | [**Scroll Page**](./node-types/scroll-page-node.mdx) |
| Navigate to the next page | [**Pagination**](./node-types/pagination-node.mdx) |
| Copy text or data | [**Extract Data**](./node-types/extract-data-node.mdx) |
| Repeat actions for a list | [**Loop**](./node-types/loop-node.mdx) |

**Key distinction:** A Workflow defines **what** the business goal is, while Nodes define **how** the browser executes each step technically.

### Node Examples

**Visit Page** opens the target URL.

<img alt="Visit Page node configured for Google Maps" />

**Input Text** enters values into a selected field.

<img alt="Input Text node configured for a Google Maps search" />

**Click Element** reproduces button and link clicks in the required order.

<img alt="Click Element nodes configured for the Google Maps example" />

**Extract Data** collects the required fields from the page.

<img alt="Extract Data node configured for restaurant records" />

### 5. Test, Publish, and Run

Test the workflow and correct any failed steps. When the result is ready, publish the Bot and run it with the required inputs.

After publishing, the automation is managed and run as a Bot. New runs use its latest published version.

## Common Building Blocks

* **Start:** Define input parameters used by the Bot.
* **Browser nodes:** Visit pages, click elements, enter text, scroll, wait, and manage tabs.
* **Logic nodes:** Add conditions, loops, list iteration, and pagination.
* **Extraction nodes:** Extract page data or data from the current list item.
* **Start:** Define the Bot inputs, browser settings, and default output format.

See **Node Types** for the configuration and usage of every available node.

## Workflow Built or Agent Built?

* Choose **Workflow Built** when you want to define and control each step in the visual builder.
* Choose **Agent Built** when you want to describe the data you need and let BrowserAct explore and build the extraction path.

Both methods create Bots that can be managed, published, and run from BrowserAct Cloud.

## Next Step

Continue to [Build Your First Workflow Built Bot](./build-your-first-bot.mdx).


# Best Practice
Source: https://docs.browseract.com/browser-proxy/browser/best-practices



| **Scenario** | **Recommended Mode** | **Proxy Suggestion** | **Configuration Logic** | **Typical Examples** |
| :- | :- | :- | :- | :- |
| **Social Media Account Management** | Standard Browser | BrowserAct Static Residential Proxy | Requires a persistent browser environment and login session. A stable, account-bound IP reduces re-authentication and lowers ban risk. | Reddit accounts<br />LinkedIn accounts<br />Instagram accounts |
| **E-commerce Price Comparison / Public Scraping** | Private Browser | BrowserAct Dynamic Proxy | Uses a clean environment on each run to avoid session tracking. IP rotation improves coverage for public extraction. | Amazon product listings<br />Walmart / Target pricing pages<br />Public e-commerce category pages |
| **SEO / Multi-region Search** | Private Browser | BrowserAct Dynamic Proxy with regional selection | Eliminates history and personalization bias. Region-based residential IPs return more accurate local search results. | Google Search (local SERPs)<br />Bing / DuckDuckGo results<br />Localized content visibility checks |
| **High-frequency Flash Sales** | Standard Browser | BrowserAct Static Residential Proxy | Maintains login state and cart/session continuity. A stable residential IP supports consistent access for time-sensitive workflows. | Limited-edition product drops<br />Ticketing platforms<br />Time-sensitive checkout workflows |
| **Staging / QA Environment Testing** | Standard Browser | BrowserAct Static Residential Proxy | Test environments may require a consistent IP. A static residential IP simplifies access control, debugging, and reproducibility. | Staging dashboards<br />Pre-production admin panels<br />Internal QA tools |
| **Seller / Vendor Dashboard Automation** | Standard Browser | BrowserAct Static Residential Proxy | Marketplaces associate seller accounts with device and IP. A static residential IP helps maintain trust signals and session continuity. | Amazon Seller Central<br />Shopify Admin<br />App marketplace vendor dashboards |

### Key Rule of Thumb

> **If an account expects you to look like the same user over time, use a BrowserAct Static Residential Proxy. If the task only needs the current page content, use a BrowserAct Dynamic Proxy.**

This rule helps you choose the appropriate browser and proxy configuration for most scenarios.


# Browser Modes & Profiles
Source: https://docs.browseract.com/browser-proxy/browser/browser-modes-profiles

This guide covers advanced browser controls for users running automation in production or at scale.

Open any Bot and select `Browser settings` to choose its browser mode.

<img alt="Choose a browser mode in Browser settings" />

## Standard Browser

### Positioning

Designed to simulate long-term, stable real-user behavior.

### How It Works

* Each Bot is assigned a fixed Browser ID.
* Cookies, cache, and browsing history are stored between runs.
* The same browser environment is reused across runs.

### Use Standard Browser When

* The Bot needs to sign in to an account and remain signed in, such as a dashboard, admin panel, or social platform.
* The same Bot runs repeatedly over time.
* The website should recognize a consistent returning browser.
* Session stability is more important than starting with a clean browser each time.

### Not Recommended For

* High-frequency account switching
* One-time public-page extraction that does not require a persistent session

## Private Browser

### Positioning

Designed for isolated, temporary browser sessions.

### How It Works

* Each run starts with a clean browser instance.
* Cookies, cache, and browsing history are not retained.
* Browser data is removed after the Task completes.

### Use Private Browser When

* The Bot accesses public pages that do not require login, such as search results, product listings, or content pages.
* Each run should be isolated from previous runs.
* You want to avoid carrying browser state between runs.
* You are testing scenarios where session persistence is unnecessary.

> **Switching modes:** When you switch from Standard Browser to Private Browser, BrowserAct warns that historical browser data will be cleared.


# Performance & Browser Maintenance
Source: https://docs.browseract.com/browser-proxy/browser/performance-maintenance

Improve page performance and manage the browser profile used by a Bot.

Open any Bot and select `Browser settings` to manage these options.

## Block Ads

Enable `Block ads` to block ads while the browser runs. This can reduce distractions and improve page loading when advertisements are not required for the Bot.

1. Open `Browser settings`.
2. Scroll to `Other Settings`.
3. Turn on `Block ads`.
4. Select `Save`.

<img alt="Enable Block ads in Other Settings" />

Keep this option off when the Bot needs to interact with or inspect advertising content.

## Browser Maintenance

The following maintenance actions apply to a `Standard Browser`, which retains browser data between runs.

### Clear Browser Data

Select `Clear browser data` to remove the Standard Browser's saved cookies, cache, browsing history, and session data. The Browser ID and browser profile remain unchanged.

Use this action when a saved session is outdated, the website is loading stale data, or you want the Bot to start with a clean browser state.

Clearing browser data signs the Bot out of websites that relied on the stored session. This action is unavailable while a Task is running.

### Refresh Browser Profile

Select `Refresh browser profile` to replace the current browser profile. Websites may recognize the refreshed profile as a new browser or device.

Use this action when clearing browser data does not resolve a browser-profile issue. You may need to sign in again after refreshing the profile.

<img alt="Clear browser data or refresh the browser profile" />


# Quick Start
Source: https://docs.browseract.com/browser-proxy/browser/quick-start

Choose the browser mode and proxy settings used by a BrowserAct Cloud Bot.

Use Browser Settings to choose the browser identity and network route used by a Bot.

## 1. Open Browser Settings

1. Open `Bots` and select any Bot.
2. Select `Browser settings`.

The entry is the same for Agent Built and Workflow Built Bots.

<img alt="Open Browser settings from a Bot" />

## 2. Choose Browser Mode

Select the browser mode that fits the target website and task.

### Standard Browser

Standard Browsing reuses a stable browser profile, including supported cookies and browser data.

**Best for:**

* Websites that require a consistent browser identity.
* Repeated tasks that depend on an authenticated session.
* Bots that need supported browser data to persist between runs.

### Private Browser

Private Browsing starts with a clean browser environment and does not retain browser data after the run.

**Best for:**

* Public pages that do not require login.
* Tasks that should start with a clean browser environment.
* Runs that do not need cookies or session data to persist.

<img alt="Choose Private Browser in Browser settings" />

## 3. Configure Proxy

Choose the network route used by the Bot.

### BrowserAct Proxy

* BrowserAct Proxy supports **Dynamic Proxy** and **Static Proxy**.
* Select the proxy mode and available region required by the Bot.
* Use a Dynamic Proxy when the task requires a rotating residential network route.
* Use a Static Proxy when the task requires a stable IP.

<img alt="Choose Dynamic Proxy or Static Proxy" />

### Custom Proxy

Use Custom Proxy when you have your own supported proxy service. Enter the required endpoint and authentication information, then use the available proxy check before running the Bot.

## 4. Save Your Settings

Select `Save` to apply the browser and proxy configuration. Unsaved changes do not affect future tasks.

## Next Step

Choose the browser identity and proxy route that match the website, save the settings, and test the complete Bot flow. For a detailed comparison, continue to [Browser Modes & Profiles](./browser-modes-profiles.mdx).


# Enable Parallel Tasks in Standard Browser
Source: https://docs.browseract.com/browser-proxy/browser/standard-browser-concurrency

Enable parallel task execution for a Bot that uses Standard Browser.

Standard Browser can run supported browser automation tasks in parallel through the `Parallel multitasking` setting. This lets multiple tasks reuse the same saved Browser Profile while reducing wait time between runs.

## How to Enable Parallel Tasks

1. Open `Bots` and select the Bot you want to configure.
2. Select `Browser settings`.
3. Confirm that the Bot is using `Standard Browser`.
4. Turn on `Parallel multitasking`.
5. Select `Save`.

<img alt="Enable Parallel multitasking in Standard Browser settings" />

## What to Know

* Each task starts from the latest saved Browser Profile available when the task launches.
* Concurrent tasks reuse the same Browser Profile as their starting point.
* Concurrent runs do not overwrite the saved Browser Profile when they finish.
* Supported entry points include regular Bot runs, Workflow debugging, API, Make, n8n, and Zapier.
* The number of tasks that can run at the same time is still subject to your account's concurrency limits.

Existing Bot data may have this setting turned off by default. Check `Browser settings` before running tasks in parallel.

## When to Use This Setting

Enable `Parallel multitasking` when you need to run multiple tasks from the same stable browser environment and can accept that the tasks share the Browser Profile available at launch.

Keep it turned off when tasks should run one at a time or when their browser state must not be shared as the starting point for other tasks.


# Troubleshooting
Source: https://docs.browseract.com/browser-proxy/browser/troubleshooting

Diagnose and resolve common browser and proxy configuration issues.

## "Clear Browser Data" Is Disabled

Browser data cannot be cleared while a Task is running.

Wait for the Task to finish, or stop it when appropriate. Then return to `Browser settings` and select `Clear browser data` again.

<img alt="Browser data cannot be cleared while a Task is running" />

## Proxy Check Failed

A Custom Proxy check can fail when:

* The server address or port is incorrect.
* The selected protocol does not match the proxy.
* The username or password is incorrect.
* The proxy endpoint is unavailable or has timed out.

Review the proxy details and run `Check proxy` again. If the information is correct but the check continues to time out, contact your proxy provider.

<img alt="Custom Proxy check failed" />

## Detected Proxy Region Does Not Match the Selected Region

After a successful proxy check, BrowserAct displays the detected region and outbound IP address.

If the detected region differs from the region selected in `Proxy settings`, choose the region that matches the proxy's actual outbound location, then confirm and save the configuration.

<img alt="Review the detected region after a successful proxy check" />

## Frequent Login or Verification Prompts

This can happen when a login-based Bot uses `Private Browser` or its browser profile changes frequently.

* Switch to `Standard Browser` to retain browser state between runs.
* Use a BrowserAct Static Residential Proxy when the website expects a consistent IP.
* Avoid clearing browser data or refreshing the browser profile unless necessary.


# Overview
Source: https://docs.browseract.com/browser-proxy/index



Browser and proxy settings control the environment a Bot uses when it runs. Use this section to configure browser behavior, session settings, network routes, and proxy options, and to troubleshoot access or performance issues.

## Browser

* **Quick Start:** Configure the browser before running a Bot.
* **Browser Modes and Profiles:** Choose the browser environment that matches the target website.
* **Runtime Environment:** Understand the environment used for each Task.
* **Best Practices:** Improve reliability when websites load slowly or behave dynamically.
* **Performance and Maintenance:** Keep browser-based automation stable over time.
* **Troubleshooting:** Diagnose browser startup, page loading, and interaction problems.

## Proxy

* **Overview:** Compare BrowserAct Dynamic Proxy, Static Proxy, and Custom Proxy.
* **Static Proxy:** Purchase, manage, and assign a fixed IP to a Cloud Bot or Agent CLI browser.
* **Dynamic Proxy:** Configure rotating residential proxy access and select a region.
* **Custom Proxy:** Connect and validate a proxy from your own provider.
* **Best Practices:** Choose a browser and proxy combination for the task.

Browser and proxy configuration does not replace website authorization. Only automate pages you are permitted to access.


# Custom Proxy
Source: https://docs.browseract.com/browser-proxy/proxy/custom-proxy-configure-use

Connect and validate a proxy from your own provider for a BrowserAct Bot.

Use Custom Proxy when you already have a proxy provider or need a network route managed outside BrowserAct.

## Video Tutorial

[![Watch Configure HTTP and SOCKS5 Custom Proxies](https://i.ytimg.com/vi/ptAwhQ8aH08/hqdefault.jpg)](https://www.youtube.com/watch?v=ptAwhQ8aH08)

[Watch **Configure HTTP and SOCKS5 Custom Proxies** on YouTube](https://www.youtube.com/watch?v=ptAwhQ8aH08).

## Add a Custom Proxy

1. Open `Bots` and select the Bot.
2. Select `Browser settings`.
3. Under **Browser Proxy**, select `Custom Proxy`.
4. Select `Add Proxy`.

<img alt="Select Custom Proxy and add a proxy" />

5. Choose a supported protocol and enter the server address and port.
6. Enter the username and password when required by your proxy provider.
7. Select the proxy region.
8. Select `Check proxy` to validate the connection.
9. After the check succeeds, select `Save`.

<img alt="Enter and validate the Custom Proxy settings" />

`Check proxy` verifies that the proxy is reachable before the Bot uses it.

## Manage Custom Proxies

After a Custom Proxy is added, you can select it for the Bot or edit and delete it from the Custom Proxy list.

BrowserAct does not manage the availability, location, rotation policy, or billing of proxies supplied by third-party providers.


# Dynamic Proxy
Source: https://docs.browseract.com/browser-proxy/proxy/dynamic-proxy-configure-use

Configure BrowserAct Dynamic Proxy for rotating residential IP access.

Dynamic Proxy uses BrowserAct's residential proxy network and can rotate the IP between runs. It is configured for a Bot and charged by usage; you do not purchase a dedicated Dynamic Proxy instance.

## Configure Dynamic Proxy

1. Open `Bots` and select the Bot.
2. Select `Browser settings`.
3. Under **Browser Proxy**, select `BrowserAct Proxy` > `Dynamic Proxy`.
4. Select the required region.
5. Select `Save`.

<img alt="Configure BrowserAct Dynamic Proxy" />

The saved proxy configuration applies when the Bot runs.

## When to Use Dynamic Proxy

Dynamic Proxy is suitable for:

* Public web data extraction
* Price and content monitoring
* Region-specific search or page results
* Tasks that benefit from IP rotation

For public extraction tasks that do not require a persistent login, pair Dynamic Proxy with **Private Browser**.

For current usage charges, see **Account, Billing & Credits FAQ**.


# Best Practices
Source: https://docs.browseract.com/browser-proxy/proxy/proxy-best-practices

Match the browser mode and proxy option to common BrowserAct use cases.

| Scenario | Recommended setup | Why |
| - | - | - |
| Account-based workflow or long-lived login | Standard Browser + Static Proxy | Keeps the browser profile and IP stable |
| Public web extraction | Private Browser + Dynamic Proxy | Provides an isolated session with rotating IP access |
| Region-specific data | Dynamic Proxy with the target region | Runs the Bot through the selected region |
| Fixed-IP allowlisting | Static Proxy | Provides a consistent IP that can be allowlisted |
| Existing proxy provider | Custom Proxy | Uses infrastructure and credentials you already manage |

## Keep Identity Consistent

For an authenticated account, avoid changing the browser profile, proxy type, or proxy region without a clear reason. Sudden identity changes may trigger additional verification from the target website.

## Match the Proxy to the Task

* Choose Static Proxy when continuity matters.
* Choose Dynamic Proxy when rotation and regional access matter.
* Choose Custom Proxy only when you can maintain and troubleshoot the external proxy.

Proxy settings can improve access, but they do not guarantee that every website or verification challenge can be completed.


# Overview
Source: https://docs.browseract.com/browser-proxy/proxy/proxy-overview

Choose a BrowserAct Dynamic Proxy, Static Proxy, or your own Custom Proxy for a Bot.

BrowserAct supports three proxy options for cloud Bots.

| Proxy option | How it works | Best for |
| - | - | - |
| Dynamic Proxy | Uses the BrowserAct residential proxy network and can rotate the IP between runs. | Public web extraction, monitoring, and region-specific results |
| Static Proxy | Assigns a purchased fixed IP to the Bot. | Account-based tasks, stable sessions, and fixed-IP workflows |
| Custom Proxy | Connects a proxy supplied by your own provider. | Existing proxy infrastructure or provider-specific requirements |

## Open Proxy Settings

Open `Bots`, select a Bot, and then select `Browser settings`. Under **Browser Proxy**, choose `BrowserAct Proxy` or `Custom Proxy`.

When using BrowserAct Proxy, select either `Dynamic Proxy` or `Static Proxy`.

<img alt="Choose Dynamic Proxy or Static Proxy in Browser settings" />

## Choose a Proxy

* Use **Static Proxy** when the Bot needs to keep a stable IP.
* Use **Dynamic Proxy** when IP rotation and regional access matter more than a fixed identity.
* Use **Custom Proxy** when you want to connect a proxy from your own provider.

See **Best Practices** for common browser and proxy combinations.


# Static Proxy
Source: https://docs.browseract.com/browser-proxy/proxy/static-proxy-purchase-use

Purchase, manage, and assign a BrowserAct Static Proxy to a cloud Bot or Agent CLI browser.

A Static Proxy provides a fixed IP for tasks that need a stable network identity, such as account-based workflows and long-lived sessions.

## Video Tutorial

[![Watch Instagram Data Scraping with Static IP Proxies](https://i.ytimg.com/vi/_QygzxJR4E4/hqdefault.jpg)](https://www.youtube.com/watch?v=_QygzxJR4E4)

[Watch **Instagram Data Scraping with Static IP Proxies** on YouTube](https://www.youtube.com/watch?v=_QygzxJR4E4).

## Purchase a Static Proxy

You can start a purchase from either location:

* Open `Proxies`, then select `Purchase Static Proxy`.
* Open a Bot, select `Browser settings` > `BrowserAct Proxy` > `Static Proxy`, then select `Purchase Static Proxy` when no suitable proxy is available.

<img alt="Purchase a Static Proxy from Bot Browser settings" />

Complete the purchase options shown in the dashboard. Static Proxy availability and cost depend on the selected location and current plan terms.

## View and Manage Static Proxies

Open `Proxies` to view purchased proxies across your account.

The list shows the proxy name and ID, IP address and location, status, auto-renew setting, creation and expiration dates, and the next billing information. You can search proxies and filter them by status.

<img alt="View and manage purchased Static Proxies" />

Review the status before assigning a proxy to a Bot. An expired proxy cannot provide the same fixed-IP continuity as an active proxy.

## Use a Static Proxy with a Cloud Bot

1. Open `Bots` and select the Bot.
2. Select `Browser settings`.
3. Under **Browser Proxy**, select `BrowserAct Proxy` > `Static Proxy`.
4. Choose an active Static Proxy from the list.
5. Select `Save`.

<img alt="Select a purchased Static Proxy for a Cloud Bot" />

For account-based tasks, pair the Static Proxy with **Standard Browser** to maintain a stable browser profile and IP.

## Use a Static Proxy with Agent CLI

Use the Static Proxy ID shown on the `Proxies` page.

Create a browser with a Static Proxy:

```bash theme={null}
browser-act browser create --type stealth --name "<browser-name>" --desc "<browser-description>" --static-proxy <static-proxy-id>
```

Assign a Static Proxy to an existing browser:

```bash theme={null}
browser-act browser update <browser-id> --static-proxy <static-proxy-id>
```

Remove the assigned proxy:

```bash theme={null}
browser-act browser update <browser-id> --no-proxy
```

Use the Static Proxy for an extraction:

```bash theme={null}
browser-act stealth-extract "<url>" --static-proxy <static-proxy-id>
```

Keep the same Static Proxy assigned when a website or account expects a consistent IP.


# Authentication & Credentials
Source: https://docs.browseract.com/credential-center/authentication-and-credentials

Store website credentials and authorize Workflow Built Bots to use them.

Credential Center stores supported website login information for Workflow Built Bots. It can reduce repeated manual login steps when a workflow accesses an authorized page.

> **Note:** Credential Center is currently available for Workflow Built Bots only. Credential hosting for Agent Built Bots is coming soon.

Credentials are encrypted and are not exposed to the platform, third parties, or language models without your authorization.

## Add a Credential

1. Open `Credential Center`.
2. Select `Add`.

<img alt="Open Credential Center and select Add" />

3. Enter a clear **Credentials Name**, such as `Google Account` or `Instagram Account`.
4. Under **Identifier(s)**, enter the same login fields used by the target website. For example, use `Email`, `Username`, `Account`, or `Tenant ID` as the key and enter the corresponding value.
5. Select `Add Another Identifier` when the website requires more than one identifier.
6. Enter the password.
7. Add an **Authenticator App Key** when the website uses supported TOTP-based 2FA. You can enter the secret key or use the QR Code option available in the form.
8. Describe where the credential should be used in **Usage Rule**, such as `Use for all Google logins`.
9. Select `Confirm`.

<img alt="Complete the Add Credential form" />

### Login with Two Fields

When the website asks for one account identifier and one password, add one Identifier and the Password. For example, an Instagram login can use the phone number, username, or email as the Identifier.

<img alt="Map a two-field login to one Identifier and Password" />

### Login with Three Fields

When the website asks for two account identifiers and one password, select `Add Another Identifier` and map both fields. For example, an AWS IAM login can use `Account ID`, `IAM username`, and `Password`.

<img alt="Map a three-field login to two Identifiers and Password" />

## Authorize a Workflow Built Bot

A saved credential is not automatically available to every Workflow Built Bot. Authorize only the workflows that need it.

### From Credential Center

1. Open `Credential Center` and locate the credential.
2. Select the authorization icon in the credential's **Actions** column.

<img alt="Open the workflow authorization settings for a credential" />

3. Under **Authorized Workflows**, select `Specific`.
4. Open `Not Authorized` and select the Workflow Built Bot that may use the credential.
5. Authorize the workflow and confirm the change.

<img alt="Select and authorize a Workflow Built Bot" />

### From the Start Node

1. Open the Workflow Built Bot and select `Workflow`.
2. Open the `Start` node.
3. Enable `Use Stored Credentials`.
4. Select `Settings` and choose an authorized credential.

<img alt="Enable Use Stored Credentials in the Start node" />

## Choose an Auto-Login Option

Configure Website Auto-Login in the `Start` node.

<img alt="Choose a Website Auto-Login option in the Start node" />

### Prompt for Credentials on Each Run

Use this option when the workflow needs different login information for each run. The user enters the required credential values when starting the task.

### Use Stored Credentials

Use this option for repeated or unattended runs. The workflow uses an authorized credential from Credential Center without asking the user to enter it again.

## Supported 2FA

Authenticator-app 2FA using a TOTP secret key or QR code is optional and can be added when the target website supports this setup.

Email and SMS verification should not be treated as supported stored-credential methods unless they are shown as available in the current product.

## Manage Credentials

### Edit a Credential

Select the edit icon in the credential's **Actions** column. Update the credential name, account information, password, Authenticator App Key, or Usage Rule, and then select `Confirm`.

<img alt="Edit an existing credential" />

If a website password changes, update the saved credential before the next run.

### Revoke Workflow Authorization

1. Open the credential's authorization settings.
2. Under **Authorized Workflows**, select `Specific`.
3. Open the `Authorized` tab.
4. Select the revoke icon for the Workflow Built Bot.
5. Confirm the change.

<img alt="Revoke a Workflow Built Bot's credential authorization" />

Revoking authorization may cause a Workflow Built Bot that depends on the credential to fail.

### View Usage Records

Select the usage-record icon in the credential's **Actions** column to review the available credential usage information.

<img alt="Open credential usage records" />

### Delete a Credential

Select the delete icon in the credential's **Actions** column when the credential is no longer needed.

<img alt="Delete a credential from Credential Center" />

Deleting a credential disables its use in authorized workflows. Check workflow dependencies before deleting it.

## Troubleshoot Login Failures

Check the following:

* The username, email, or account identifier matches the target website.
* The password has not changed or expired.
* The account is not locked or suspended.
* The Authenticator App Key is current and entered correctly.
* The Workflow Built Bot is authorized to use the credential.
* `Use Stored Credentials` is enabled in the Start node when stored credentials are required.

When contacting support, include the Task ID and the login error shown by the run. Do not send passwords or 2FA secret keys.


# Overview
Source: https://docs.browseract.com/credential-center/credential-center-overview



Credential Center manages supported website login information for Workflow Built Bots.

Use it when a Workflow Built Bot needs to access a page that is not publicly available and BrowserAct supports the site's authentication flow.

> **Note:** Credential Center is currently available for Workflow Built Bots only. Credential hosting for Agent Built Bots is coming soon.

## What You Can Manage

* Supported username and password credentials
* Supported authenticator-app 2FA keys
* Workflow Built Bot authorization
* Auto-login options available in the product
* Credential usage records

## Add a Credential

1. Open `Credential Center`.
2. Create a credential using the available credential type.
3. Enter the required login information.
4. Add supported 2FA information when needed.
5. Save the credential.

## Authorize a Workflow Built Bot

A stored credential is not automatically available to every Workflow Built Bot. Authorize the specific Workflow Built Bot that needs to use it.

Review and revoke authorization when a Bot no longer needs access.

## Supported 2FA

The existing Credential Center documentation supports authenticator-app 2FA. Email and SMS verification should not be treated as supported unless they become available in the product.

## Security Practices

* Grant access only to the Workflow Built Bots that require it.
* Update stored information after a password change.
* Review usage records for unexpected access.
* Remove unused credentials.
* Do not enter passwords or 2FA secrets in an Agent Built request. Credential Center does not apply to Agent Built Bots.

See [Authentication and Credentials](./authentication-and-credentials.mdx) for the existing detailed procedure.


# Agent & Integrations FAQ
Source: https://docs.browseract.com/faq/agent-integrations-faq



## Can I use BrowserAct through MCP in QwenPaw?

Yes, if QwenPaw supports connecting to a remote MCP server. Create a BrowserAct MCP Server, expose the required Bot as an MCP Tool, and add the MCP Server URL and API key to QwenPaw.

Both Workflow Built Bots and Agent Built Bots support MCP. See [Integrate BrowserAct with MCP](/integrations/mcp) for the setup steps.

## Can BrowserAct MCP connect to the Claude.ai web app?

Not currently. Support for connecting BrowserAct MCP to Claude.ai on the web is under development.

## Can I use BrowserAct with AI agents other than Claude?

Yes. BrowserAct Bots can connect to supported Claude clients, such as Claude Desktop and Claude Code, and to other compatible AI agents through MCP.

Create a BrowserAct MCP Server, expose the Bot as an MCP Tool, and connect the server to your MCP client with the MCP Server URL and API key.

BrowserAct provides connection guidance for clients such as Claude Desktop, Claude Code, Cursor, Windsurf, Gemini CLI, VS Code, and supported API-based agent environments.

For setup details, see [Workflow Built MCP setup](/integrations/mcp#convert-a-workflow-built-bot-into-an-mcp-tool) or [Agent Built MCP setup](/integrations/mcp#convert-an-agent-built-bot-into-an-mcp-tool).

## Why does a REST API request return an authorization error when I use an API key created from the MCP Server?

The API key created from the MCP Server panel is only used for MCP Server access. It cannot be used for REST API requests. MCP Server and REST API are separate modules, and their API keys are managed separately.

* **MCP Server key:** Used only for MCP client connections.
* **REST API key:** Used only for BrowserAct REST API calls.

## Where are API keys managed?

Open `Integrations` and select `Manage API Keys` to create, copy, edit, or delete an API key. For endpoints and API-based webhooks, see the API Reference.

## Is Google Sheets a direct BrowserAct integration?

Not directly. Connect BrowserAct to Make, n8n, or Zapier, then add Google Sheets as the next step in your automation.

## Can I integrate BrowserAct with platforms other than Make, n8n, and Zapier?

Yes. Use the BrowserAct API to connect a Bot to another application or automation platform. BrowserAct Bots can also be exposed as MCP Tools for supported AI agents and MCP clients.

Make, n8n, and Zapier provide ready-to-use integration paths. Other platforms can connect through the API or MCP, depending on the platform's capabilities.

## How do I schedule a BrowserAct Bot to run automatically?

Use BrowserAct schedules when you want BrowserAct to run a published Bot automatically and email results from inside BrowserAct. See [Schedule Bot Runs](/bot/schedules/schedule-bot-runs) for setup steps.

Use Make, n8n, or Zapier when you want an external automation platform to trigger the Bot and continue into other apps, such as Google Sheets, Slack, email, a database, or a CRM. In those platforms, schedule options, time zones, retries, and limits depend on the automation platform.


# Account, Billing & Credits FAQ
Source: https://docs.browseract.com/faq/billing-credits-faq



## Does BrowserAct support team member subaccounts or adding teammates?

Not yet. BrowserAct Cloud accounts are currently managed individually and do not include teammate invitations, member roles, or shared workspaces.

## How do I change my account email or password?

You cannot currently change the email address linked to your BrowserAct account.

To reset your password, open the account menu at the bottom of the BrowserAct dashboard, select `Account Settings`, and select `Reset` beside the Password field. If you cannot sign in, use the password reset option on the login page.

<img alt="Open Account Settings from the account menu" />

## How do I delete my BrowserAct account?

Account deletion is not currently available as a self-service option. Contact Support to request account deletion.

Before submitting the request, make sure you no longer need the account. Deleting it permanently removes all Bot and Workflow data and clears any remaining credits. Deleted data and credits cannot be recovered.

## Is it still possible to buy permanent credit packs or bundles?

No. Credit Packs are valid for the current monthly credit cycle.

You need an active subscription to purchase a Credit Pack. Pack credits expire at the next monthly credit reset and do not roll over.

This monthly reset rule also applies when the subscription itself is billed yearly.

## How can I get an invoice?

Create a ticket in the BrowserAct Discord community or email `support@browseract.com`. Include your order information, and the Support team will verify the purchase and issue the invoice.

Do not send full payment-card details, passwords, or other sensitive account information.

## How is a Static Proxy charged?

Static Proxies are charged in credits per proxy, per month. Pricing varies by location and proxy tier and is shown before purchase.

## Can BrowserAct provide the original username and password for a Static Proxy?

No. BrowserAct does not currently provide the original username and password for a Static Proxy. Use the proxy through the supported BrowserAct configuration and access methods.

## How is a Dynamic Proxy charged?

Dynamic Proxy usage costs **5,000 credits per GB**. Your total charge depends on the traffic generated by your Tasks.

## How is a local fingerprint browser charged?

Each local fingerprint browser costs **100 credits** to create.

Creating a replacement after deleting a browser incurs another 100-credit charge.

## How can I earn bonus credits?

* **Approved G2 review: 2,000 credits.** Publish an honest BrowserAct review. After the review is approved, send the approval screenshot to BrowserAct Support for verification.
* **New account registration reward.** Eligible new users may receive bonus credits. The amount is subject to change; review the offer shown during registration or in the current promotion.
* **Star the BrowserAct GitHub repository: 500 credits.** Star the official BrowserAct GitHub repository and follow the current verification instructions to claim the reward.

Rewards are subject to account eligibility and verification. A G2 reward is for an authentic, approved review and is not conditional on the opinion being positive.

## How can I check my credit usage?

Credit usage for both Agent CLI and BrowserAct Cloud is available in the Billing Dashboard.

1. Sign in to BrowserAct.
2. Open `Plan & Billing`.
3. Select `Dashboard`.

You can also open the [Billing Dashboard](https://www.browseract.com/reception/payment?tab=dashboard) directly. It shows total credits consumed, usage by service, usage trends, and detailed usage history.

## Why did I receive no registration credits after signing up?

Registration credits are available to the first eligible BrowserAct account registered from an IP address. If more than one account was created from the same IP address, only the first eligible account receives the reward.

Check whether another BrowserAct account has already been registered from your current network. If you still need help, contact Support with your account information.

## How do I apply for the BrowserAct Affiliate Program?

Visit the [BrowserAct Affiliate Program](https://www.browseract.com/affiliate) and submit the registration form. Once approved, you can earn commission by sharing BrowserAct through your affiliate link.

## When are affiliate commissions paid, and what is the minimum payout?

Affiliate commissions are settled once a month. The minimum payout is **\$50**.

## How long does an affiliate referral link remain valid?

Affiliate referral links do not expire and can be shared at any time. When a user registers through your link, attribution is based on their latest valid tracked referral interaction.

## How do I cancel my subscription?

1. Open `Plan & Billing` from the BrowserAct dashboard.
2. Select the `Subscription` tab.
3. Locate the active subscription and choose the cancellation option.
4. Complete the confirmation steps shown in the account backend.

Your subscription will remain active until the end of the current billing cycle and will not renew.

<img alt="Open Plan & Billing and select Subscription" />


# Bot FAQ
Source: https://docs.browseract.com/faq/bot-faq



## All Bots

### Where can I see a Bot run?

Each build and run creates a Task. Open `Tasks` to view activity across all Bots. To view tasks for one Bot, open the Bot and select `History`.

### Why do I get an error when I run two Tasks on the same Bot?

A Bot using `Standard Browser` supports one active Task at a time because its runs reuse the same persistent browser environment.

To run multiple Tasks in parallel, open the Bot's `Browser settings` and switch to `Private Browser`. Also make sure your BrowserAct plan supports the number of concurrent Tasks you need.

### How do I get a Bot ID?

Open `Bots` and hover over a Bot card to reveal its ID. You can also open the Bot and find the ID in the page URL. Select the copy icon to copy it.

A `Workflow ID` shown in a legacy or third-party interface is the Bot ID.

### Can I share a Bot with another user?

It depends on how the Bot was built.

* **Agent Built Bot:** Copying and sharing are not currently supported.
* **Workflow Built Bot:** You can save the Bot as a personal template and share the template.

To create a shareable template, open `Bots`, select the three-dot menu on the Workflow Built Bot card, and select `Save as Template`.

<img alt="Save a Workflow Built Bot as a template for sharing" />

The recipient uses the template to create a separate Bot. This does not give them access to your original Bot, run history, or credentials.

### How does BrowserAct reduce the cost of running a Bot after it has been built?

BrowserAct builds Agent Built Bots as reusable, script-based automations. The Agent provides intelligence during building, testing, and supported recovery, while routine runs use the published automation instead of repeating the full reasoning process.

This reduces repeated model and token usage while keeping execution fast and predictable.

### Can a Bot handle CAPTCHA or human verification?

Yes. BrowserAct automatically detects and handles supported CAPTCHA and verification challenges. When a challenge needs manual input, BrowserAct can continue through human-in-the-loop assistance.

Email or SMS codes, device confirmations, and account-specific checks may require your input.

### What types of CAPTCHA and human verification does BrowserAct support?

BrowserAct supports common verification systems, including:

* Google reCAPTCHA v2
* Google reCAPTCHA v3
* Google reCAPTCHA Enterprise
* Cloudflare Turnstile
* Cloudflare Challenge
* DataDome
* HUMAN Security (PerimeterX)

BrowserAct attempts supported checks automatically and uses human-in-the-loop assistance when manual input is needed.

### What should I do if BrowserAct cannot complete a CAPTCHA?

CAPTCHA behavior varies by website and verification provider. If BrowserAct cannot complete a challenge, contact Support and include the target URL, Bot ID, and Task ID. The team will investigate the verification flow and assess the required adaptation.

### Can BrowserAct be used on websites that require login?

Yes. BrowserAct supports login-protected websites.

* **Workflow Built Bots:** Save the account in Credential Center, authorize the Bot, and enable stored credentials in the Start node. You can also prompt for credentials on each run. See [Authorize a Workflow Built Bot](../credential-center/authentication-and-credentials.mdx#authorize-a-workflow-built-bot).
* **Agent Built Bots:** Complete the login through human-in-the-loop assistance. Select `Standard Browser` so the browser can retain and reuse the authenticated session in later runs. Managed credential hosting for Agent Built Bots is coming soon.

If the website requests a code, device confirmation, or another account-specific check, complete it through human-in-the-loop assistance.

## Agent Built Bots

### Can I copy or share an Agent Built Bot?

No. Agent Built Bots do not currently support copying or sharing.

### How do I update an Agent Built Bot?

Open the Agent Built Bot and select `Improve Bot` to update its behavior or extraction fields. Describe the change, test the draft, and publish it. Future runs use the new `Live` version.

`Improve Bot` applies only to Agent Built Bots.

### Can an Agent Built Bot use stored login credentials?

Not yet. For a login-protected website, sign in through human-in-the-loop assistance and select `Standard Browser` to retain the session for future runs.

Credential hosting for Agent Built Bots is coming soon.

## Workflow Built Bots

### Can I close the browser window after I run a Workflow Built Bot?

Yes. After you start the run, the Workflow Built Bot continues running in BrowserAct Cloud. You can close the BrowserAct page or your browser window without stopping the Task.

To check the status or results later, open the Bot and select `History`. You can also open `Tasks` to view activity across all Bots.

### Can a Workflow Built Bot run a login-protected process?

Yes. Save the login in Credential Center, authorize the Workflow Built Bot, and enable stored credentials in the Start node.

See [Authorize a Workflow Built Bot](../credential-center/authentication-and-credentials.mdx#authorize-a-workflow-built-bot) for the complete setup process.

Complete any account-specific verification through the available human-in-the-loop flow.


# General Troubleshooting
Source: https://docs.browseract.com/faq/existing-troubleshooting



## What should I do if my Bot build fails?

Open the failed build Task and review its status and error details. Then check the target URL, login or verification requirements, and the Bot's Browser and Proxy settings before trying the build again.

If the build still fails, contact Support and include the Bot ID, Task ID, target URL, and a screenshot of the issue.

## A Task Failed

1. Open Tasks and select the failed Task.
2. Review the available status, result, and error details.
3. Confirm that the target page is available in a normal browser.
4. Check whether the page requires login, verification, a region, or a specific network route.
5. Review the Bot's Browser and Proxy settings.
6. Run the Bot again after correcting the identified issue.

## A Login Failed

1. Confirm that the same login information works directly on the target website.
2. Update the saved item in Credential Center if the password changed.
3. Confirm that the credential is authorized for the correct Bot.
4. Check whether the website requires an unsupported email or SMS verification step.

Never send a password, verification code, or 2FA secret to support.

## A Workflow Built Bot Returned No Data

* Add a Scroll Page or Scroll to Element node if the content is outside the visible area.
* Open the required detail page before extracting fields that are not present in the list.
* Use Extract Data for page-level or list extraction and Extract Data Item inside the relevant repeated-item flow.
* Add Wait when dynamic content has not loaded before extraction begins.
* Confirm that the Bot is logged in when the data is available only to an authorized account.

## A Workflow Built Bot Returned Partial Results or Missing Fields

* Confirm that the field is visible on the page or open the required detail page.
* Check the item limit, pagination, Loop, and Loop List settings.
* Add Wait when the page has not finished loading.
* Confirm that the field is present on every record.
* Review regional, login, proxy, or website changes that may affect the returned records.

## What Is the Difference Between Extract Data and Extract Data Item?

Use **Extract Data** for page-level fields, a detail page, the full page, or the current visible area. It does not require **Loop List**.

Use **Extract Data Item** inside **Loop List** when you need the same fields from every repeated item, such as product cards, jobs, posts, or comments.

To collect fields from each detail page, use **Loop List** with **Click Element Item** to open each item, then use **Extract Data** on the detail page.

## What Is the Difference Between Loop and Loop List?

Use **Loop** to repeat a process until an exit condition or maximum iteration count is reached. Typical uses include pagination, scrolling, and clicking **Load more**.

Use **Loop List** to process repeated items in a page list. Add **Extract Data Item** or **Click Element Item** as its child node.

## A Workflow Built Bot Did Not Download a File

* Confirm that the download control is visible and clickable.
* Check whether a login prompt, pop-up, or verification step is blocking the action.
* Add **Wait** when the page or download request needs more time.
* Confirm that the website starts the download through a supported browser interaction.

Open the completed Task to review the available download result. A login-protected download requires an authorized and active session.

## A Website Changed

For a Workflow Built Bot, open the Workflow Builder, update the affected nodes, test the Workflow, and publish the updated Bot.

For an Agent Built Bot, open Build and use `Improve Bot` to describe the changed page or expected result. Review and publish the draft before using the update.

## What Should I Do If a Website Is Not Accessible?

1. Confirm that the website opens normally in your browser.
2. Retry the Task after a short wait.
3. Review the Bot's browser mode and proxy region in `Browser settings`.
4. Try another supported proxy region when access is location-dependent.
5. If the issue continues, contact Support with the website URL, Bot ID, Task ID, and a screenshot.

## Contact Support

Include the Bot ID, Task ID, target URL, expected behavior, actual behavior, and a screenshot with sensitive information removed.


# Getting Started FAQ
Source: https://docs.browseract.com/faq/getting-started-faq



## What does BrowserAct Cloud create?

BrowserAct Cloud creates reusable Bots that automate browser tasks and return structured data.

## Where Does BrowserAct Bot Run?

BrowserAct Bots run in BrowserAct Cloud. You do not need to install software, maintain a server, or keep your computer turned on after starting a Task.

You can close the BrowserAct page or browser window while a Bot is running. Return to the Bot's `History` or open `Tasks` to check its status and results.

## Does BrowserAct handle login walls or only public pages?

Both. BrowserAct works with public pages and login-protected pages.

For a Workflow Built Bot, save and authorize the login through Credential Center. For an Agent Built Bot, sign in through human-in-the-loop assistance and use `Standard Browser` to retain the login session. Managed credentials for Agent Built Bots are coming soon.

## What is the difference between Agent Built and Workflow Built?

Both methods create a Bot.

* **Agent Built:** Describe the result you need in natural language. BrowserAct builds and tests the Bot for you.
* **Workflow Built:** Build the process yourself by connecting and configuring nodes in the visual editor.


# Overview
Source: https://docs.browseract.com/faq/index



Find quick answers about BrowserAct Cloud, Bots, integrations, billing, and troubleshooting.

## FAQ Categories

* **Getting Started FAQ:** Product basics, login-protected pages, and build methods.
* **Bot FAQ:** Shared Bot behavior, Agent Built questions, Workflow Built login, verification, and troubleshooting paths.
* **Agent & Integrations FAQ:** Other AI agents, MCP, API keys, and integration availability.
* **Account, Billing & Credits FAQ:** Account boundaries, subscriptions, Credit Packs, invoices, infrastructure charges, rewards, and cancellation.
* **General Troubleshooting:** Task failures, login failures, missing data, and website changes.

For task, login, and extraction issues, see **Troubleshooting**. For browser or network issues, see **Browser & Proxy > Troubleshooting**.


# BrowserAct Cloud
Source: https://docs.browseract.com/index

Start with BrowserAct Cloud documentation.

# BrowserAct Cloud

BrowserAct Cloud is the default starting point for BrowserAct documentation.

Start with [Introduction](/overview/what-is-browseract-cloud) to learn what BrowserAct Cloud is, when to use it, and how it relates to Agent CLI.

If you are looking for local browser control for your own agent workflow, open the [Agent CLI documentation](/agent-cli/introduction).


# API Keys & Authentication
Source: https://docs.browseract.com/integrations/api-keys

Create and manage API keys used to connect BrowserAct to supported tools and integrations.

API keys authenticate BrowserAct integrations and API requests. An API key grants access to your account, so keep it private and create separate keys when you need to manage connections independently.

## Open API Key Management

1. Open `Integrations` in the BrowserAct dashboard.
2. Select `Manage API Keys`.

The Integrations page also shows the API server, API documentation, supported tools, and integration platforms.

<img alt="Open Manage API Keys from Integrations" />

## Create an API Key

1. In the API Keys window, select `Create New API Key`.

<img alt="Create a new API key" />

2. Enter a name that identifies where the key will be used.
3. Choose a **CLI Action Confirmation** mode.

### Confirmation Required

Critical actions initiated through the CLI must be confirmed on the BrowserAct page before execution can continue. These actions can include purchases and creating or deleting assets.

### Allow Automatic Execution

The connected agent can complete supported CLI actions without additional confirmation, including critical actions shown in the product warning.

Use this mode only for a trusted environment where unattended execution is required.

4. Select `Confirm`.

<img alt="Name the API key and choose its confirmation mode" />

## Copy and Manage API Keys

The API Keys list shows each key's name, masked key value, mode, creation time, and last-used time.

Use the icons in the **Actions** column to:

* Copy the API key
* Edit its name or confirmation mode
* Delete the API key

<img alt="Copy, edit, or delete an API key" />

Deleting a key stops integrations and clients that depend on it from authenticating. Update the connected tool before removing a key that is still in use.

## API Usage Limits

* **Rate limits:** No rate limits.
* **Free users:** 1 task per run.
* **Paid users:** Up to 20 concurrent tasks.
* **Task duration:** Up to 7 hours per task.

## Security Practices

* Do not place API keys in prompts, screenshots, public repositories, or shared documents.
* Use a separate key for each integration when practical.
* Prefer `Confirmation Required` unless automatic critical actions are necessary.
* Delete keys that are no longer used.
* If a key is exposed, delete it and create a replacement.

For endpoints, request headers, task status, result retrieval, and Webhooks, see the existing **API Reference**.


# Send BrowserAct Data to Google Sheets
Source: https://docs.browseract.com/integrations/guides/google-sheets

Use Make to send structured BrowserAct Bot results to Google Sheets.

Google Sheets is used as a downstream application through Make. BrowserAct runs the Bot, Make processes the structured result, and Google Sheets stores each record as a row.

## Before You Start

* Prepare a BrowserAct Bot that runs successfully.
* For a Workflow Built Bot, set `Default Output Format` to `JSON` in the `Start` node.
* Create a Google Sheet with column headers that match the fields you want to store.
* Create a BrowserAct API key from `Integrations` > `Manage API Keys`.

## Build the Make Scenario

1. Create a scenario in Make and add the BrowserAct app.

<img alt="Add BrowserAct to a Make scenario" />

2. Select `Run a Workflow`, connect your BrowserAct account, and choose the Workflow that corresponds to your Bot.

<img alt="Connect BrowserAct and select the Workflow" />

3. Configure the required Bot inputs.

<img alt="Configure the BrowserAct inputs in Make" />

4. Add `JSON` > `Parse JSON` and generate the data structure from a successful BrowserAct result.

<img alt="Add Parse JSON to the scenario" />

<img alt="Generate the JSON data structure" />

5. If the result contains an array of records, add an `Iterator` after `Parse JSON`.
6. Add `Google Sheets` > `Add a Row`.

<img alt="Add Google Sheets to the Make scenario" />

7. Select the spreadsheet and sheet, then map each BrowserAct result field to the matching column.

<img alt="Map BrowserAct result fields to Google Sheets columns" />

8. Run the scenario once and confirm that the rows are written correctly before activating it.

> **Naming note:** Make may display `Workflow` or `Run a Workflow`. These labels refer to the corresponding BrowserAct Bot.

## Troubleshooting

* If Make cannot parse the result, run the Bot again and use a complete JSON result to generate the data structure.
* If fields are missing, confirm that the Bot output and Google Sheets headers match.
* If no row is created, check the Google account connection and spreadsheet permissions.

See [Integrate BrowserAct with Make](../make.mdx) for the complete connection setup.


# Import and Export Make Scenarios as JSON
Source: https://docs.browseract.com/integrations/guides/make-json-import-export

Share or reuse a Make scenario that contains BrowserAct modules by using a JSON blueprint.

Make blueprints let you move or share a Make scenario as a JSON file. The file describes the scenario structure, modules, routes, filters, and mappings.

The blueprint does not include a working BrowserAct connection or account credentials. After importing a blueprint, reconnect BrowserAct and any other apps before running or activating the scenario.

## Import a Make Blueprint

1. Log in to [Make](https://www.make.com/).
2. Open `Scenarios` and create a new scenario.
3. Open the scenario menu and select `Import Blueprint`.

<img alt="Open Import Blueprint in Make" />

4. Choose the JSON blueprint file and confirm the import.

<img alt="Choose the Make blueprint JSON file" />

5. Review the imported modules, routes, filters, and mapped inputs.
6. Reconnect the BrowserAct module and any other applications used in the scenario.
7. Select the Workflow that corresponds to your BrowserAct Bot and verify its inputs.
8. Run the scenario once before activating it.

## Export a Make Blueprint

1. Open the Make scenario.
2. Open the scenario menu and select `Export Blueprint`.

<img alt="Open Export Blueprint in Make" />

3. Save the JSON file.

<img alt="Save the exported Make blueprint" />

## Share the Blueprint

After exporting the JSON file, you can share it with teammates, clients, or the Make community. Recipients can import the file by following the import steps above.

Before sharing a blueprint, review it for fixed values, test data, or other sensitive information. API keys and application credentials should never be added directly to the JSON file.

## Tips

* Review imported scenarios before activating them.
* Reconnect BrowserAct, API keys, and third-party app accounts after import.
* Check required input fields before running the scenario.
* Use clear file names when saving blueprint files.
* Add notes inside Make if the scenario will be shared with another user.

> A Make blueprint is a Make scenario file, not a BrowserAct Bot export.


# Import and Export n8n Workflows as JSON
Source: https://docs.browseract.com/integrations/guides/n8n-json-import-export

Share or reuse an n8n workflow that contains BrowserAct nodes by using a JSON file.

n8n workflows can be imported and exported as JSON. The file contains the workflow structure, nodes, connections, expressions, and mappings.

Credentials are managed separately in n8n. After importing a workflow, configure the BrowserAct API credential and reconnect any other app credentials before running or activating it.

## Import an n8n Workflow

1. Log in to your n8n workspace, either n8n Cloud or a self-hosted instance.
2. Create a new workflow to open a blank canvas.
3. Open the workflow menu and select `Import from File`.

<img alt="Open Import from File in n8n" />

4. Choose the JSON workflow file.

<img alt="Choose the n8n workflow JSON file" />

5. Review the imported nodes, connections, expressions, and input mappings.
6. Install or enable the BrowserAct node if n8n requests it.
7. Create or select the BrowserAct API credential.
8. Select the Workflow that corresponds to your BrowserAct Bot and configure its inputs.
9. Execute the node, verify the result, and activate the workflow when it is ready.

## Export an n8n Workflow

1. Open the n8n workflow.
2. Open the workflow menu and select `Download`.

<img alt="Download the n8n workflow as JSON" />

3. Save the JSON file.

<img alt="Save the exported n8n workflow" />

## Share the Workflow

After downloading the JSON file, you can share it with teammates, clients, or the n8n community. Recipients can import the file by following the import steps above.

Before sharing the file, remove fixed secrets and review any embedded sample data. n8n credentials are managed separately and must be reconnected after import.

## Best Practices

* Review imported workflows before activating them.
* Reconfigure BrowserAct and third-party credentials after import.
* Run a test execution to verify that the workflow works as expected.
* Check expressions, mapped fields, and required inputs after import.
* Use descriptive file names for JSON exports.
* Keep versioned copies when you make major workflow changes.

## Troubleshooting

* If the BrowserAct node is unavailable, install or enable the BrowserAct node in your n8n instance.
* If a workflow fails after import, check that all required credentials and third-party integrations are configured.
* If input fields are missing, reselect the Workflow that corresponds to your BrowserAct Bot.
* Review the n8n execution logs to identify configuration or mapping issues.

> An n8n workflow JSON file is an n8n automation file, not a BrowserAct Bot export.


# Schedule BrowserAct Bot Runs
Source: https://docs.browseract.com/integrations/guides/scheduled-runs

Choose BrowserAct schedules or Make scheduling to run a BrowserAct Bot automatically.

Use BrowserAct schedules when you want BrowserAct to run a published Bot automatically and email results based on changes or successful runs. Condition-based result emails are currently supported for Agent Built Bot schedules.

Use Make scheduling when a BrowserAct Bot needs to run at a recurring time or interval and then continue into other Make modules.

For native BrowserAct schedules, see [Schedule Bot Runs](/bot/schedules/schedule-bot-runs).

## Set Up a Make Scheduled Run

1. Create a Make scenario and add the BrowserAct app.

<img alt="Add BrowserAct to a Make scenario" />

2. Select `Run a Workflow`, connect your BrowserAct account, and choose the Workflow that corresponds to your Bot.

<img alt="Connect BrowserAct and select the Workflow" />

3. Enter or map the required Bot inputs.
4. Open the scenario scheduling control.
5. Choose the interval, date, time, or supported schedule that fits the task.

<img alt="Configure the Make scenario schedule" />

6. Run the scenario once to verify the Bot and downstream modules.
7. Save and activate the scenario.

Review execution status in Make. In BrowserAct, open `Tasks` to view activity across all Bots, or open a specific Bot and select `History`.

## Common Uses

* Monitor prices or availability.
* Collect recurring reports.
* Refresh lead or market data.
* Send scheduled results to Google Sheets, a database, or another application.

> **Naming note:** Make may display `Workflow` or `Run a Workflow`. These labels refer to the corresponding BrowserAct Bot.

See [Integrate BrowserAct with Make](../make.mdx) for API key, connection, and input mapping instructions.


# Overview
Source: https://docs.browseract.com/integrations/integration-overview



Integrations let another automation platform start a tested BrowserAct Bot and use its results.

> **Naming note:** BrowserAct manages these automations as **Bots**. Some third-party integrations may still display labels such as `Workflow`, `My Workflows`, or `Run a Workflow`. In those interfaces, the Workflow refers to the corresponding BrowserAct Bot.

## Before You Connect a Bot

Confirm that:

* The Bot builds and runs successfully in BrowserAct
* Required inputs are clearly defined
* The output fields are stable
* You have copied the correct Bot ID
* You have an API Key when the connection requires one

## Available Integration Paths

* `Make`: build visual business automation scenarios.
* `n8n`: build technical workflows with branching and transformations.
* `Zapier`: connect a Bot to supported triggers and actions.
* `MCP`: connect BrowserAct to compatible MCP clients.
* `API Keys`: create and manage the credentials used by supported integrations.

API request examples, authentication headers, task status, results, callbacks, and endpoint definitions remain in the existing API Reference.

Connect BrowserAct with Make, n8n, Zapier, or MCP to build end-to-end automations around your Bots. For example, you can trigger a Bot from a schedule or external event, pass in dynamic inputs, receive structured results, and then send the data to Google Sheets or another downstream application.

For native scheduled Bot runs and BrowserAct result emails, see [Schedule Bot Runs](/bot/schedules/schedule-bot-runs).

For custom integrations using the BrowserAct API or Webhooks, see the existing API Reference.

## Integration Guides

* [Send BrowserAct Data to Google Sheets](./guides/google-sheets.mdx)
* [Schedule BrowserAct Bot Runs](./guides/scheduled-runs.mdx)
* [Import and Export Make Scenarios as JSON](./guides/make-json-import-export.mdx)
* [Import and Export n8n Workflows as JSON](./guides/n8n-json-import-export.mdx)

## Typical Flow

```text theme={null}
External trigger
  -> Run BrowserAct Bot
  -> Check Task status
  -> Read structured result
  -> Send result to the next application
```


# Integrate BrowserAct with Make
Source: https://docs.browseract.com/integrations/make

Run a BrowserAct Bot from Make and send its structured results to other applications.

Use the BrowserAct app in Make to run a Bot from a scenario and pass its results to downstream modules such as Google Sheets, Slack, email, a database, or a CRM.

## Video Tutorial

[![Watch BrowserAct and Make Automation Tutorial](https://i.ytimg.com/vi/5tt0ZtcpwY8/hqdefault.jpg)](https://www.youtube.com/watch?v=5tt0ZtcpwY8)

[Watch **BrowserAct and Make Automation Tutorial** on YouTube](https://www.youtube.com/watch?v=5tt0ZtcpwY8).

> **Naming note:** BrowserAct calls the automation a **Bot**. The current Make app may still display `Workflow` or `Run a Workflow`; these labels refer to the corresponding BrowserAct Bot.

## Available Actions

This guide uses the following Make actions:

* `Run a Workflow`: runs a Workflow Built Bot and returns a Task ID for tracking.
* `Make an API Call`: performs an authorized BrowserAct API request.

<img alt="Choose a BrowserAct module in Make" />

## Before You Start

Prepare the following:

* A BrowserAct Bot that runs successfully
* The Bot's required input values
* A BrowserAct API key
* A Make account

To create an API key, open `Integrations` > `Manage API Keys` > `Create New API Key`. Enter a name, choose the confirmation mode, select `Confirm`, and copy the key from the API Keys list.

## Connect BrowserAct to Make

1. In Make, create a scenario or open an existing one.
2. Add the trigger that should start the scenario.
3. Add a module and search for `BrowserAct`.
4. Select the BrowserAct app.

<img alt="Select the BrowserAct app in Make" />

5. Choose `Run a Workflow`.
6. Under **Connection**, select `Add`.
7. Enter a connection name and paste the BrowserAct API key.
8. Select `Save`.

<img alt="Create a Make connection with a BrowserAct API key" />

## Select a Bot

1. Under `Search Workflows From`, choose `My Workflows (With Published Version Only)` for your own Workflow Built Bots, or `Template Marketplace` for available templates.

<img alt="Choose where Make should search for BrowserAct Workflows" />

2. Open the `Workflow` field.
3. Choose the Workflow that corresponds to your BrowserAct Bot.
4. If Make does not list the Bot, refresh the field or reconnect the BrowserAct account.

The following example selects a Workflow Built Bot through Make's current `Workflow` field.

<img alt="Select a Workflow Built Bot in Make" />

## Map Bot Inputs

After a Bot is selected, Make displays the input parameters required by that Bot.

For each parameter, either:

* Enter a fixed value.
* Map a value from an earlier Make module.

For example, a Bot input named `keyword` can receive a fixed search term or a value submitted by a form, Webhook, spreadsheet row, or CRM record.

<img alt="Configure the BrowserAct connection and Bot input parameters" />

## Test the Scenario

1. Select `Run once` in Make.
2. Trigger the scenario with test data.
3. Confirm that BrowserAct creates a Task.
4. Review the BrowserAct module output in Make.
5. If the Task fails, open the related Task in BrowserAct and review its status and result.

## Use Bot Results

Add another Make module after BrowserAct and map the returned fields to the destination.

Common destinations include:

* Google Sheets
* Slack or email
* Airtable or Notion
* A database
* A CRM
* An AI processing step

Google Sheets is used as a downstream Make module; it is not configured as a direct BrowserAct integration.

## Schedule Runs

Use BrowserAct schedules when you want BrowserAct to run a published Bot automatically and email results from inside BrowserAct. See [Schedule Bot Runs](/bot/schedules/schedule-bot-runs).

Use Make's scheduling settings when the Bot should run automatically as part of a Make scenario.

1. Configure and test the complete scenario.
2. Open the scenario scheduling settings.
3. Choose the required interval or schedule.
4. Save and activate the scenario.

The available schedules, time zones, retries, and plan limits are controlled by Make.

## Common Scenarios

### Scheduled Data Collection

Run a BrowserAct Bot on a Make schedule and send the structured result to Google Sheets, a database, or email.

```text theme={null}
Make Scheduler > BrowserAct > Google Sheets or Database > Email
```

### Lead Enrichment

Use a form, CRM event, or Webhook to provide a company name or website. Run the BrowserAct Bot and write the enriched result back to the CRM.

```text theme={null}
Form or CRM Trigger > BrowserAct > CRM Update
```

### Price Monitoring and Alerts

Run a product-monitoring Bot at a regular interval, compare the returned value, and notify the team when a condition is met.

```text theme={null}
Make Scheduler > BrowserAct > Filter > Slack or Email
```

## Troubleshooting

| Problem | What to check |
| - | - |
| Authentication failed | Copy the current API key again, remove extra spaces, or create a new Make connection. |
| Bot is not listed | Confirm that the Bot runs in BrowserAct, refresh the Workflow field, and reconnect BrowserAct if needed. |
| Required input is missing | Confirm that every required Bot input has a fixed or mapped value. |
| Task returns no data | Run the Bot with the same inputs in BrowserAct and review the resulting Task. |
| Task takes too long | Check the target website, Bot inputs, Browser and Proxy settings, and unnecessary Wait nodes in a Workflow Built Bot. |

For current BrowserAct actions available in Make, see the [BrowserAct integration on Make](https://www.make.com/en/integrations/browser-act).


# Integrate BrowserAct with MCP
Source: https://docs.browseract.com/integrations/mcp

Turn BrowserAct Bots into MCP Tools and connect them to MCP clients.

BrowserAct MCP Server lets compatible MCP clients discover and run BrowserAct Bots as MCP Tools.

> **Naming note:** The MCP interface currently uses `Workflow`. In the new BrowserAct product structure, the completed automation is managed as a Bot, and a legacy Workflow ID corresponds to the Bot ID.

## What Is BrowserAct MCP Server?

BrowserAct MCP Server connects MCP clients to BrowserAct Bots through the Model Context Protocol. A connected client can discover exposed tools, provide inputs, run the Bot, and receive its result.

You can use it to:

* Run browser automation from a chat or agent interface
* Pass runtime inputs in natural language
* Return results as text or files
* Expose multiple BrowserAct Bots from one MCP Server

## Supported MCP Clients

BrowserAct can connect to clients that support the required MCP server transport and authentication method, including clients shown in the current BrowserAct setup interface.

Compatibility depends on the client, not only on the AI model name. For a client that is not listed, follow its instructions for adding a generic MCP Server.

## Before You Start

Prepare the following:

* A BrowserAct account
* A published BrowserAct Bot
* An MCP-compatible client
* A Bot that does not require manual credential input on every run

## How to Use MCP

BrowserAct supports two MCP setup paths:

* Convert an Agent Built Bot into an MCP Tool from the Bot's `Integrations` tab.
* Convert a Workflow Built Bot into an MCP Tool from the Workflow Builder's MCP configuration.

## Convert an Agent Built Bot into an MCP Tool

Use this path when the Bot was created with Agent Built.

### Step 1: Select the Bot to Expose

1. Open `Bots`.
2. Find the Agent Built Bot you want to expose as an MCP Tool.
3. Select the Bot.

<img alt="Select an Agent Built Bot from the Bots page" />

### Step 2: Create an MCP Server and Expose the Tool

#### Create an MCP Server

1. Open the Bot's `Integrations` tab.
2. Find the `MCP` card.
3. Select `MCP Server`.

<img alt="Open MCP Server from an Agent Built Bot" />

Before exposing the Bot, you can review or edit the MCP Tool's basic information from the settings icon on the `MCP` card. BrowserAct generates the Tool Call Name, Tool Description, and input descriptions automatically, but you can adjust them before exposing the Bot to MCP clients.

<img alt="Open Agent Built MCP Tool settings" />

<img alt="Edit Agent Built MCP Tool configuration" />

Select `Add MCP Servers`, enter a server name and optional description, then select `Confirm`.

<img alt="Create an MCP Server for an Agent Built Bot" />

#### Expose the Tool

After the MCP Server is created, select the `Server Management` icon for that server.

<img alt="Open Server Management for the MCP Server" />

1. Open `Exposed Tools`.
2. Select `Not Exposed`.
3. Select the Bot you want to expose.
4. Select the expose action, then confirm.

<img alt="Expose an Agent Built Bot as an MCP Tool" />

### Step 3: Connect an MCP Client

You can configure the client manually or ask an AI agent such as Codex or Claude Code to help complete the connection.

#### Option 1: Configure the Client Manually

1. Open `Connect to Clients` for the MCP Server.
2. Copy the MCP Server URL.
3. Create or copy the API Key from the same MCP Server.
4. Select the MCP client you want to connect, then follow the setup instructions shown in BrowserAct.
5. Reload the client if required and confirm that the exposed Agent Built Bot appears as an available MCP Tool.

<img alt="Copy the MCP Server URL and API Key" />

<img alt="Open the setup guide for an MCP client" />

Use the MCP Server URL and API Key from the same server. Do not share the API Key in prompts, screenshots, repositories, or public configuration files.

#### Option 2: Configure Quickly with an Agent

Send the following prompt to your agent. Replace the example URL with the MCP Server URL from BrowserAct. Keep the key placeholder until the agent begins its secure local configuration flow, and only provide the key in a trusted session.

````text theme={null}
Connect to BrowserAct via its MCP server and return structured output.

## MCP Server
- URL: https://mcp.browseract.com/************/mcp/
- Transport: Streamable HTTP (type: "http")
- Auth: `Authorization: Bearer <BROWSERACT_MCP_KEY>`

IMPORTANT: The authentication header must use the `Authorization: Bearer` format, not `x-api-key` or another header name.

## Before calling the tool
Verify that the `browseract` MCP server is connected in the current session. If it is not connected or configured, do not continue. Instead, provide the setup command and guide me through completing the connection.

For Claude Code, use:

```bash
claude mcp add --transport http --header "Authorization: Bearer <KEY>" --scope user browseract "<URL>"
```

For another agent, provide the equivalent configuration command or file location for that agent, then verify the connection before calling the tool.
````

<img alt="Configure the BrowserAct MCP connection with an AI agent" />

### Step 4: Run an MCP Tool

After the client confirms that the `browseract` MCP Server is connected and the exposed tool is available, run the tool with either of the following methods.

#### Run from a Standard MCP Client

Include the required runtime inputs in the request. For example:

```text theme={null}
Run the BrowserAct tool for this URL and return the structured result:
https://example.com
```

#### Run from an Agent

Ask the agent to use the connected BrowserAct MCP Tool in natural language. For example:

```text theme={null}
Use BrowserAct MCP to crawl posts about Codex on Reddit.
```

The agent should select the exposed tool, supply its required inputs, and return the result in the requested format.

<img alt="Run an exposed BrowserAct MCP Tool from an AI agent" />

Open the MCP Server's execution logs to review status, duration, and errors.

## Convert a Workflow Built Bot into an MCP Tool

Use this path when the Bot was created with Workflow Built.

### Step 1: Select the Workflow Built Bot to Expose

1. Open the Workflow Built Bot.
2. Select `MCP Configure`.
3. Turn on `MCP-Ready`.

<img alt="Open MCP Configure in a Workflow Built Bot" />

Turning on `MCP-Ready` does not activate the tool immediately. Publish the Workflow after completing the configuration.

### Configure the Tool

Enter the following information:

* **Tool Call Name:** Use 2-32 characters. Start with a letter and use only letters, numbers, and underscores. The name must be unique within the account.
* **Description:** Explain what the tool does and when the MCP client should use it.
* **Tool Output Method:** Choose `Text` or `File` based on the expected result.

Clear tool names and descriptions help the MCP client select the correct tool.

<img alt="Enable and configure the MCP Tool" />

#### Configure Input Parameters

Choose how each Workflow input is provided:

* **AI-Inferred:** The MCP client supplies the value at runtime. Add a clear parameter description.
* **Fixed Value:** BrowserAct uses the same value for every execution.

MCP Tools do not support credentials entered manually for each run. Use credentials stored and authorized through Credential Center.

After the configuration is published, update the Workflow and publish again when its MCP parameters need to change.

#### Publish the Workflow

Select `Publish` after the MCP configuration is complete. MCP clients run the latest published configuration; unpublished changes are not available to them.

### Step 2: Create an MCP Server and Expose the Tool

Open the MCP Server page:

1. Open `Integrations` in BrowserAct Cloud.
2. Find the `MCP` section.
3. Select the `MCP` card.

<img alt="Open MCP from the BrowserAct Integrations page" />

1. Select `Add` on the MCP Server page.

<img alt="Add an MCP Server" />

2. Enter a unique Server Name.
3. Add an optional description.
4. Select `Confirm`.

<img alt="Enter the MCP Server name and description" />

Expose the Workflow Built Bot as an MCP Tool:

1. Select `Management` for the target MCP Server.

<img alt="Open MCP Server management" />

2. Open `Exposed Tools` and select `Not Exposed`.
3. Find the MCP Tool and select the expose action.

<img alt="Select a Workflow Built Bot that has not been exposed" />

4. Review the notice and select `Confirm`.

<img alt="Confirm that the MCP Tool should be exposed" />

Only published, MCP-ready Bots can be exposed. One MCP Server can expose multiple MCP Tools.

### Step 3: Connect an MCP Client

Each MCP Server has its own MCP Server URL and API Key. Use the matching pair from the same server.

You can configure the client manually or ask an AI agent such as Codex or Claude Code to help complete the connection.

#### Option 1: Configure the Client Manually

Get the Server URL and API Key:

1. Open `Management` for the target MCP Server.
2. Open `Connect to Clients`.
3. Copy the MCP Server URL.
4. Select `Create New API Key`, then copy the generated key from the Actions column.

<img alt="Copy the MCP Server URL and API Key" />

This is the MCP Server connection key. It is managed from the MCP Server, not from the general `Manage API Keys` page.

Configure the client:

1. Select the target MCP client in `Connect to Clients`.
2. Open the setup instructions for that client.
3. Add the MCP Server URL and API Key to the client's configuration.
4. Reload the client if required.
5. Confirm that the exposed BrowserAct tools are available.

<img alt="Open the setup guide for an MCP client" />

Do not expose the API Key in prompts, screenshots, repositories, or shared configuration files.

#### Option 2: Configure Quickly with an Agent

Send the following prompt to your agent. Replace the example URL with the MCP Server URL from BrowserAct. Keep the key placeholder until the agent begins its secure local configuration flow, and only provide the key in a trusted session.

````text theme={null}
Connect to BrowserAct via its MCP server and return structured output.

## MCP Server
- URL: https://mcp.browseract.com/************/mcp/
- Transport: Streamable HTTP (type: "http")
- Auth: `Authorization: Bearer <BROWSERACT_MCP_KEY>`

IMPORTANT: The authentication header must use the `Authorization: Bearer` format, not `x-api-key` or another header name.

## Before calling the tool
Verify that the `browseract` MCP server is connected in the current session. If it is not connected or configured, do not continue. Instead, provide the setup command and guide me through completing the connection.

For Claude Code, use:

```bash
claude mcp add --transport http --header "Authorization: Bearer <KEY>" --scope user browseract "<URL>"
```

For another agent, provide the equivalent configuration command or file location for that agent, then verify the connection before calling the tool.
````

<img alt="Configure the BrowserAct MCP connection with an AI agent" />

### Step 4: Run an MCP Tool

After the client confirms that the `browseract` MCP Server is connected and the exposed tool is available, run the tool with either of the following methods.

#### Run from a Standard MCP Client

Include the required runtime inputs in the request. For example:

```text theme={null}
Run the BrowserAct tool for this URL and return the structured result:
https://example.com
```

#### Run from an Agent

Ask the agent to use the connected BrowserAct MCP Tool in natural language. For example:

```text theme={null}
Use BrowserAct MCP to crawl posts about Codex on Reddit.
```

The agent should select the exposed tool, supply its required inputs, and return the result in the requested format.

<img alt="Run an exposed BrowserAct MCP Tool from an AI agent" />

Open the MCP Server's execution logs to review status, duration, and errors.

## Troubleshooting

### Authentication Error

* Confirm that the API Key belongs to the selected MCP Server.
* Copy the key again from `Management > Connect to Clients`.
* Confirm that the key has not been revoked or deleted.

### MCP Client Cannot Find Tools

* Confirm that the MCP Server URL is correct.
* Confirm that the MCP Server is online.
* Confirm that at least one tool is exposed.
* Confirm that the Bot is MCP-ready and published.
* Reload the MCP client after changing the configuration.

### MCP Client Cannot Run a Tool

* Check the BrowserAct credit balance.
* Confirm that every required input is available.
* Improve the tool and parameter descriptions if the client selects or fills them incorrectly.
* Review the MCP Server execution logs.

## MCP Limits and Behavior

### Can Agent Built Bots Be Used as MCP Tools?

Yes. Agent Built Bots can be exposed as MCP Tools from the Bot's `Integrations` tab. See [Convert an Agent Built Bot into an MCP Tool](#convert-an-agent-built-bot-into-an-mcp-tool).

### Can Every Workflow Built Bot Be Exposed?

Most can be exposed, except Bots that require users to enter credentials manually on every run.

### How Many MCP Servers Can I Create?

* Free accounts: 1 MCP Server
* Paid accounts: Unlimited MCP Servers

### How Many Tools Can One Server Expose?

There is no fixed tool-count limit. One MCP Server can expose multiple MCP Tools.

### Do MCP API Keys Expire?

They do not expire by default. You can revoke or regenerate them from MCP Server management.

### What Happens When the Workflow Changes?

Publish the updated Workflow. MCP clients use the latest published configuration and continue using the previous one until the update is published.

### What Happens When the MCP Server Is Offline?

MCP clients cannot connect to or run its tools. The exposure configuration remains saved.


# Integrate BrowserAct with n8n
Source: https://docs.browseract.com/integrations/n8n

Run a BrowserAct Bot from n8n and use its structured results in an automation workflow.

Use the verified BrowserAct node in n8n to run a BrowserAct Bot and pass its structured results to other nodes in the workflow.

## Video Tutorial

[![Watch Integrate BrowserAct with n8n](https://i.ytimg.com/vi/2CfEBOfpRcM/hqdefault.jpg)](https://www.youtube.com/watch?v=2CfEBOfpRcM)

[Watch **Integrate BrowserAct with n8n in 60 Seconds** on YouTube](https://www.youtube.com/watch?v=2CfEBOfpRcM).

> **Naming note:** BrowserAct calls the automation a **Bot**. The current n8n node uses `Workflow` and `Run a Workflow`; these labels refer to the corresponding BrowserAct Bot.

## Before You Start

Prepare the following:

* A BrowserAct Bot that runs successfully
* The Bot's required input values
* A BrowserAct API key
* An n8n Cloud or self-hosted n8n instance

Verified nodes may need to be enabled by the n8n instance owner before other users can add them.

To create an API key, open `Integrations` > `Manage API Keys` > `Create New API Key`. Enter a name, choose the confirmation mode, select `Confirm`, and copy the key from the API Keys list.

## Add the BrowserAct Node

1. In n8n, create a workflow or open an existing one.
2. Select `+` to add a node.

<img alt="Add a node to the n8n workflow" />

3. Search for `BrowserAct` and open the verified BrowserAct node.

<img alt="Search for the BrowserAct node in n8n" />

4. If prompted, select `Install node`.

<img alt="Install the verified BrowserAct node" />

5. Select `Run a workflow` to add the action to the canvas.

<img alt="Select the Run a workflow action" />

## Connect BrowserAct to n8n

1. Open the BrowserAct node.
2. Under **Credential to connect with**, create a new BrowserAct credential.
3. Paste the BrowserAct API key.
4. Save and select the credential.

<img alt="Create a BrowserAct credential in n8n" />

## Select a Bot

1. Set the BrowserAct resource to `Workflow` when this field is shown.
2. Set the operation to `Run a Workflow`.
3. Under `Search Workflows From`, choose `Template Marketplace` or `My Workflows`.
4. Choose the Workflow that corresponds to the BrowserAct Bot.
5. Refresh the field or reconnect the credential if the Bot is not listed.

<img alt="Choose where n8n searches for BrowserAct workflows" />

The n8n node may continue to use Workflow terminology until the third-party integration is updated.

<img alt="Configure the BrowserAct Run a Workflow node in n8n" />

## Map Bot Inputs

After a Bot is selected, configure each input required by the Bot.

For each input, either:

* Enter a fixed value.
* Use an n8n expression to map data from an earlier node.

For example, a Bot input named `company_url` can receive a value from a form submission, Webhook, spreadsheet row, database query, or CRM record.

## Test the Workflow

1. Execute the BrowserAct node with test data.
2. Confirm that BrowserAct creates a Task.
3. Review the node output in n8n.
4. If the Task fails, open the related Task in BrowserAct and review its status and result.
5. Save the n8n workflow after the test succeeds.

## Use Bot Results

Add downstream n8n nodes and map fields returned by BrowserAct.

Common destinations include:

* Google Sheets
* Slack, Telegram, or email
* Airtable or a database
* A CRM
* WordPress or another publishing system
* An AI processing node

Google Sheets is used as a downstream n8n node; it is not configured as a direct BrowserAct integration.

## Schedule Runs

Use BrowserAct schedules when you want BrowserAct to run a published Bot automatically and email results from inside BrowserAct. See [Schedule Bot Runs](/bot/schedules/schedule-bot-runs).

Use an n8n schedule trigger when the Bot should run automatically as part of an n8n workflow.

1. Add a schedule trigger before BrowserAct.
2. Configure the required interval and time zone.
3. Test the complete workflow.
4. Save and activate it.

The available schedules, retries, execution limits, and time zones are controlled by the n8n instance and plan.

## Common Scenarios

### Collect Data and Update Google Sheets

Run a BrowserAct Bot, add the structured result to Google Sheets, and notify a Slack channel.

```text theme={null}
Schedule Trigger > BrowserAct > Google Sheets > Slack
```

### Enrich Leads

Read a company or contact from a form, spreadsheet, or CRM, run BrowserAct, and write the enriched fields to the destination.

```text theme={null}
Input Source > BrowserAct > CRM or Database
```

### Create a Content Pipeline

Collect source data with BrowserAct, process it with an AI node, and send the result to a publishing or review step.

```text theme={null}
Trigger > BrowserAct > AI Processing > WordPress or Review Queue
```

## Troubleshooting

| Problem | What to check |
| - | - |
| BrowserAct node is unavailable | Confirm that the verified node is enabled for the n8n instance. |
| Authentication failed | Copy the current API key again, remove extra spaces, or recreate the n8n credential. |
| Bot is not listed | Confirm that the Bot runs in BrowserAct, refresh the Workflow field, and reconnect the credential if needed. |
| Input parameter is missing | Confirm that every required Bot input has a fixed value or valid n8n expression. |
| Task returns no data | Run the Bot with the same inputs in BrowserAct and review the resulting Task. |
| Task takes too long | Check the target website, Bot inputs, Browser and Proxy settings, and unnecessary Wait nodes in a Workflow Built Bot. |

For the current verified node and community workflow examples, see the [BrowserAct integration on n8n](https://n8n.io/integrations/browseract/).


# Integrate BrowserAct with Zapier
Source: https://docs.browseract.com/integrations/zapier

Run a BrowserAct Bot from Zapier and send its structured results to other apps.

Use the BrowserAct app in Zapier to run a Bot and pass its structured results to the next step in a Zap.

> **Naming note:** BrowserAct calls the automation a **Bot**. The current Zapier action uses `Workflow` and `Run a Workflow`; these labels refer to the corresponding BrowserAct Bot. A `Workflow ID` shown in a legacy or third-party interface is the Bot ID.

## Before You Start

Prepare the following:

* A BrowserAct Bot that runs successfully
* The Bot's required input values
* A BrowserAct API key
* A Zapier account

To create an API key, open `Integrations` > `Manage API Keys` > `Create New API Key`. Enter a name, choose the confirmation mode, select `Confirm`, and copy the key.

## Add BrowserAct to a Zap

1. In Zapier, create a Zap or open an existing one.
2. Configure the app and event that will trigger the Zap.
3. Add an Action step.
4. Search for and select `BrowserAct`.
5. Select `Run a Workflow` as the Action event.

BrowserAct currently provides an Action and does not start a Zap as a trigger.

## Connect Your BrowserAct Account

1. Select `Sign in` or add a new BrowserAct connection.
2. Paste your BrowserAct API key when prompted.
3. Save and select the connection.

API keys grant access to your BrowserAct account. Do not share them publicly.

## Select a Bot

1. Under `Search Workflows From`, choose your own published Workflows or the Template Marketplace.
2. Select the Workflow that corresponds to the BrowserAct Bot.
3. Complete the input fields shown for that Bot.

Zapier normally lets you select the Bot from a list instead of entering its ID manually. If a Workflow ID is displayed or requested, use the corresponding Bot ID.

## Map Bot Inputs

For each required Bot input, enter a fixed value or map data from the Zap trigger or an earlier step.

For example, a Bot input named `company_url` can receive a URL from a form submission, spreadsheet row, CRM record, or email.

## Test the Action

1. Test the BrowserAct Action with sample input values.
2. Confirm that BrowserAct creates a Task.
3. Review the returned fields in Zapier.
4. If the Task fails, open it in BrowserAct to review the status and result.

After the test succeeds, add the next Zap step and publish the Zap.

## Use Bot Results

Map the structured fields returned by BrowserAct to another Zapier app, such as:

* Google Sheets
* Gmail
* Airtable
* Google Drive
* A CRM
* Slack or another notification app

Google Sheets is used as a downstream Zapier app; it is not configured as a direct BrowserAct integration.

## Common Scenarios

### Run a Bot on a Schedule

Use BrowserAct schedules when you want BrowserAct to run a published Bot automatically and email results from inside BrowserAct.

Use Schedule by Zapier when the scheduled Bot run should continue into other Zapier apps.

```text theme={null}
Schedule by Zapier > BrowserAct > Google Sheets
```

### Enrich Form or CRM Data

Pass a submitted URL or company record to BrowserAct, then write the returned fields to a CRM or spreadsheet.

```text theme={null}
Form or CRM Trigger > BrowserAct > CRM or Spreadsheet
```

### Monitor Data and Send an Alert

Run BrowserAct after a scheduled or application event, then send the result by email or team notification.

```text theme={null}
Trigger > BrowserAct > Gmail or Notification App
```

## Troubleshooting

| Problem | What to check |
| - | - |
| BrowserAct is not available | Search for the current BrowserAct app when adding an Action. |
| Authentication failed | Copy the current API key again, remove extra spaces, or reconnect the BrowserAct account. |
| Bot is not listed | Confirm that the Bot runs in BrowserAct and check the selected Workflow source. |
| An input is missing | Confirm that every required input has a fixed value or mapped field. |
| The Action returns no data | Run the Bot with the same inputs in BrowserAct and review the resulting Task. |

For the current Action and available app pairings, see the [BrowserAct integration on Zapier](https://zapier.com/apps/browseract/integrations).


# Core Capabilities
Source: https://docs.browseract.com/overview/core-capabilities



BrowserAct Cloud combines AI-assisted building, real-browser execution, managed browser infrastructure, and structured data delivery.

## Why Choose BrowserAct Cloud?

### Extract Data With One Prompt

Describe the website, conditions, and fields you need. Agent Built turns the request into a reusable Bot with no code or selectors.

### Build Once. Run Reliably.

Build and test the Bot once, then reuse it with new inputs. A monitoring Agent can recover from supported page changes, while permanent updates are reviewed and published as a new version.

### Agent Builds. Stable Scripts Run.

The Agent handles building and supported repairs. Routine runs use deterministic automation for faster execution, lower token usage, and more predictable results.

### Anti-Bot and Cloud Operations Handled for You

BrowserAct manages real cloud browsers, browser identities, proxies, and supported verification handling, reducing the infrastructure you need to maintain.

### Workflow-Ready Structured Output

Export results as CSV or JSON, use the BrowserAct API, or connect your Bots to Make, n8n, and Zapier.

## How BrowserAct Cloud Works

The following atomic capabilities work together to support the product value above.

### 1. Stealth Fingerprint Browser Engine

BrowserAct runs on real Chromium browsers with browser fingerprint protection that reduces detectable automation and virtualization signals.

### 2. Global Residential Proxy Network

Residential IPs, regional selection, and supported proxy rotation help reduce IP blocking and rate limits while matching the target market.

### 3. Automatic CAPTCHA Handling

BrowserAct can automatically handle supported CAPTCHA and verification flows, including common challenges such as reCAPTCHA, Cloudflare Turnstile, and DataDome. Support does not guarantee resolution of every challenge.

### 4. Multiple Browser Identities

Private Browser provides an isolated identity for temporary sessions. Standard Browser supports a more stable browser identity for tasks that require persistent browser state.

### 5. Natural-Language Task Understanding

Describe the data you need. Agent Built translates the request into extraction logic and validates it against the live website without requiring code or selectors.

### 6. Agent Build and Deterministic Execution

The Agent focuses on building and supported repairs. Routine runs use deterministic automation for faster execution, low token usage, and more predictable results.

### 7. Page Awareness and Self-Repair

A monitoring Agent follows each run and can repair supported page-structure changes during execution. Recovered paths can be reused by later runs; permanent Bot updates still follow the review and publish flow when required.

### 8. Cloud Browser Runtime

Browser instances run in the cloud without consuming local computer resources. Managed cloud resources support scalable execution and keep tasks independent of the user's local machine.

### 9. Full-Spectrum Integrations

Export CSV or JSON, connect Bots to Make, n8n, and Zapier, or use the BrowserAct API to return structured JSON to your own systems.

## Next Step

Go to Quick Start to build and run your first Agent Built Bot.


# Introduction
Source: https://docs.browseract.com/overview/what-is-browseract-cloud



BrowserAct Cloud is a cloud-based AI web data extraction platform. Describe the target website, filters, and data fields in natural language, with no code or selectors required.

BrowserAct explores and tests the live website to build a reusable Bot that you can run with new inputs and improve as your requirements or the website changes.

Each run returns clean, structured data that you can export as CSV or JSON, access through the BrowserAct API, or send to Make, n8n, and Zapier.

**Build once. Run reliably. Improve continuously.**

BrowserAct manages the cloud browser environment, Bot runs, Tasks, and structured results, so you do not need to install a local Agent or maintain browser infrastructure.

## Ways to Build a Bot

BrowserAct Cloud provides two ways to build a Bot:

* **Agent Built:** Describe the website, records, fields, and conditions in natural language. BrowserAct explores and tests the live website, then builds the Bot for you.
* **Workflow Built:** Build the process in the visual Workflow Builder by configuring nodes for navigation, interaction, extraction, conditions, loops, and output.

Both methods create Bots that can be managed and run from BrowserAct Cloud. Their building experiences are different, so each method has its own documentation under **Build a Bot**.

## What You Can Build

BrowserAct Cloud is designed for repeatable data extraction from complex websites, including pages that use:

* JavaScript-rendered content
* Search forms and filters
* Pagination or load-more interactions
* Listing pages and detail pages
* Tabs, pop-ups, and multi-step navigation
* Region-specific content

Common examples include collecting product information, reviews, public posts, business listings, supplier data, job listings, or competitor information.

## Who BrowserAct Cloud Is For

BrowserAct Cloud is useful for:

* Operations and research teams that need structured web data
* Marketing and growth teams conducting market or competitor research
* Small businesses that do not have dedicated automation engineers
* Agencies building repeatable data workflows for clients
* Developers who want a hosted Bot instead of maintaining browser infrastructure

## What You Get

A published Bot can:

* Accept configurable input values
* Reuse the published data extraction process
* Return results using the Bot's defined output fields
* Keep a record of its tasks and results
* Connect to supported automation tools

## BrowserAct Cloud and Agent CLI

BrowserAct offers two ways to work with browser automation: fully managed execution in BrowserAct Cloud, or local browser control through Agent CLI as part of your own Agent workflow.

| Dimension | BrowserAct Cloud | Agent CLI |
| - | - | - |
| Execution environment | Runs in BrowserAct's managed cloud environment | Runs on your local machine or in your own Agent environment |
| Local Chrome state | Does not reuse your local Chrome login state | Can reuse supported local Chrome profiles or browser sessions |
| Computing resources | Uses managed cloud browser resources | Uses your local machine and environment |
| Primary users | Business users and teams using BrowserAct directly or through Make, n8n, Zapier, and API integrations | Developers and AI Agents using commands, Skills, or developer tools |
| Primary workflow | Build and run reusable web data extraction Bots | Add browser control to a local development or Agent workflow |

Choose BrowserAct Cloud when you want BrowserAct to manage the browser environment and Bot execution for you. Choose Agent CLI when you want your own Agent workflow to control a local browser directly. See the [Agent CLI documentation](https://docs.browseract.com/agent-cli/introduction) to get started.

## Next Step

Go to [Core Capabilities](./core-capabilities.md) to learn why teams choose BrowserAct Cloud and which capabilities support reliable extraction.


# Build Your First Bot
Source: https://docs.browseract.com/quick-start/build-your-first-bot



This guide takes you from describing a data request to your first structured result.

## Video Tutorial

[![Watch Build a Reusable Web Scraper from One Prompt](https://i.ytimg.com/vi/1M11lfNW7rE/hqdefault.jpg)](https://www.youtube.com/watch?v=1M11lfNW7rE)

[Watch **Build a Reusable Web Scraper from One Prompt** on YouTube](https://www.youtube.com/watch?v=1M11lfNW7rE).

## Before You Start

You need a BrowserAct account before you can build a Bot.

1. Open the [BrowserAct website](https://www.browseract.ai/doc) and select `Start Free Trial`.

<img alt="Select Start Free Trial on the BrowserAct website" />

2. Create your account with an email and password, or continue with Google or GitHub.

<img alt="Create an account with email, Google, or GitHub" />

3. Complete the required registration and onboarding questions to enter the Cloud dashboard.

***

## Quick Start

## Step 1: Describe What You Need

On Home, start Agent Built in either of these ways:

* Select one of the configured prompt templates below the prompt box.
* Enter your own request directly in the prompt box.

<img alt="Choose a prompt template or enter your own request on Home" />

You can also select `Create`, then choose `Start building` under `Build with Agent`.

<img alt="Select Create and start building with Agent" />

For a clear request, include:

* **Website:** Where BrowserAct should start
* **Records:** What items or pages to collect
* **Conditions:** Keywords, categories, locations, filters, or date ranges
* **Fields:** The exact data to return
* **Limit:** How many results you need
* **Inputs:** Values you want to change in future runs

Example:

```text theme={null}
Go to the Amazon Best Sellers page and collect the top 20 products
from the Clothing, Shoes & Jewelry department. Return the rank,
product name, price, rating, review count, image URL, and product URL.
```

Submit the request when it describes the result you expect.

## Step 2: Let BrowserAct Build and Test the Bot

BrowserAct explores the live website, determines how to reach the requested records, and tests the extraction.

During the build, BrowserAct may navigate pages, apply filters, scroll, follow pagination, open detail pages, and validate output fields.

<img alt="BrowserAct exploring and building the Bot" />

If BrowserAct asks for more information, reply in the same build conversation. Add the missing URL, condition, field, example, or expected result.

Some websites may require login or verification. Complete a supported user-assistance step only when BrowserAct requests it and you are authorized to access the page.

## Step 3: Run the Bot and Get Results

When the build is complete, select `Run` at the bottom of the Build page to run the Bot.

<img alt="Enter the Bot inputs and start the run" />

When the run is complete, review the structured result.

<img alt="Review the structured results after the run completes" />

If an Agent Built Bot needs different fields or a changed navigation path, open its Build page and use [Improve Bot](../bot/improve/improve-a-bot.md).

## What to Do Next

* Learn how Agent Built works in detail.
* Configure Browser and Proxy settings when the website has a regional or session requirement.
* Open Tasks to inspect run status and results.
* Connect a tested Bot to Make, n8n, or Zapier.


# BrowserAct Community
Source: https://docs.browseract.com/support/community

Join the BrowserAct community to ask questions, share use cases, and provide product feedback.

Join the [BrowserAct Discord community](https://discord.com/invite/UpnCKd7GaU) to connect with BrowserAct users and the product team.

## Use the Community For

* Product and setup questions
* Workflow Built and Agent Built use cases
* Make, n8n, Zapier, and MCP discussions
* Sharing automation examples
* Product feedback and feature requests

## Before You Post

Search the Help Center and existing Discord discussions first. When asking about a failed Bot or Task, include:

* Bot ID and Task ID
* Target website
* Expected and actual behavior
* Relevant error message
* Screenshot with sensitive information removed

Do not post API keys, passwords, verification codes, stored credentials, or private account information in a public channel.

For an account, payment, or private product issue, create a support ticket or email [support@browseract.com](mailto:support@browseract.com).


# Contact Support
Source: https://docs.browseract.com/support/contact-support



## Discord

Join the [BrowserAct Discord community](https://discord.com/invite/UpnCKd7GaU) and create a support ticket.

## Email

Email [support@browseract.com](mailto:support@browseract.com).

## What to Include

For a product issue, include the Bot ID, Task ID, target URL, expected behavior, actual behavior, and a screenshot with sensitive information removed.

For an invoice request, include the order information needed to identify the purchase.

Never send passwords, verification codes, credential secrets, or full payment-card details.


# Overview
Source: https://docs.browseract.com/support/index



Use this section when you need help beyond the product guides and troubleshooting articles.

## Contact Support

Find the current channel for contacting BrowserAct Support. Before contacting support, collect the Bot ID, Task ID, target URL, expected behavior, and a screenshot with sensitive information removed.

## Community

Join the BrowserAct community to discuss use cases, ask product questions, and learn from other users.

## Tutorials & Resources

Browse additional tutorials and resources for building and running BrowserAct Bots.

For task, login, CAPTCHA, or extraction issues, review **FAQ > Troubleshooting** first. For browser and network issues, review **Browser & Proxy**.


# Tutorials & Resources
Source: https://docs.browseract.com/support/tutorials-resources

Find BrowserAct guides, examples, integrations, API documentation, and product resources.

Use these Help Center sections to continue learning BrowserAct Cloud.

## Get Started

* [**Quick Start**](../quick-start/build-your-first-bot.md): Build and run a first Agent Built Bot from a natural-language request.
* [**Agent Built**](../bot/agent-built/agent-built.md): Learn how to describe, build, test, publish, run, and improve a Bot.
* [**Workflow Built**](../bot/workflow-built/overview.mdx): Build a Bot by connecting browser-operation nodes.

## Build Workflow Automations

* [**Node Types**](../bot/workflow-built/node-types/index.md): Review every available Workflow node and its configuration.
* [**Workflow Troubleshooting**](../faq/existing-troubleshooting.mdx): Resolve issues with extraction, loops, missing fields, partial results, and downloads.
* [**Case Studies**](../bot/workflow-built/case-studies/list-to-detail.mdx): Follow complete Workflow Built examples based on real websites.

## Connect BrowserAct

* [**Make**](../integrations/make.mdx): Run a BrowserAct Bot from a Make scenario.
* [**n8n**](../integrations/n8n.mdx): Use the verified BrowserAct node in an n8n workflow.
* [**Zapier**](../integrations/zapier.mdx): Run BrowserAct as an Action in a Zap.
* [**MCP**](../integrations/mcp.mdx): Expose BrowserAct Bots as MCP Tools.
* [**API Reference**](https://docs.browseract.com/api-reference/tasks/create-a-task): Integrate BrowserAct through the current API endpoints.

## Additional Resources

* [BrowserAct Blog](https://www.browseract.com/blog)
* [BrowserAct Discord Community](https://discord.com/invite/UpnCKd7GaU)
* [BrowserAct Skills on GitHub](https://github.com/browser-act/skills)

For product issues, account questions, or invoice requests, open [**Contact Support**](./contact-support.mdx).


# List official bot templates
Source: https://docs.browseract.com/workflow/api-reference/bot-templates/list-official-bot-templates

/openapi_3.json get /v3/bots/templates
Returns a paginated list of official Bot templates curated by BrowserAct.

Use `keyword` for a case-insensitive template name search. Use the returned `template_id` with the template detail or run endpoint.



# Retrieve an official bot template
Source: https://docs.browseract.com/workflow/api-reference/bot-templates/retrieve-an-official-bot-template

/openapi_3.json get /v3/bots/templates/{template_id}
Fetches an official Bot template, including the standard JSON `input_schema` required when creating a template run. If you only need a list of templates, use `GET /v3/bots/templates`.



# List bots
Source: https://docs.browseract.com/workflow/api-reference/bots/list-bots

/openapi_3.json get /v3/bots
Returns a paginated list of Bots that have a runnable published version.

### Filtering
- Use `bot_type` to select a Bot type.
- Use `keyword` for a case-insensitive Bot name search.

### Pagination
Use `page` and `limit`. The response includes `total_pages` and `total_count`.



# Retrieve a bot
Source: https://docs.browseract.com/workflow/api-reference/bots/retrieve-a-bot

/openapi_3.json get /v3/bots/{bot_id}
Fetches a Bot definition, including its creation time and published schemas. For an unpublished Bot owned by the current company, `published_at`, `input_schema`, and `output_schema` are null; attempting to run it returns error code `10020`. If you only need a list of runnable Bots, use `GET /v3/bots`.



# List supported proxy regions
Source: https://docs.browseract.com/workflow/api-reference/regions/list-supported-proxy-regions

/openapi_3.json get /v3/bots/regions
Returns the Bot proxy regions visible to the current API key. Pass a returned region `code` as `proxy_region` when creating an official template run.



# Cancel a running task
Source: https://docs.browseract.com/workflow/api-reference/tasks/cancel-a-running-task

/openapi_3.json post /v3/bots/runs/{task_id}/cancel
Cancels a running or paused task. Optionally provide `biz_code`; when omitted, the default user-cancel code is used. A task already in a terminal state (`finished`, `canceled`, or `failed`) returns error code `10121` and cannot be resumed.



# List tasks
Source: https://docs.browseract.com/workflow/api-reference/tasks/list-tasks

/openapi_3.json get /v3/bots/runs
Returns a paginated list of Bot execution tasks.

### Filtering
- Use `status` to filter by task status.
- Use `bot_id` to list tasks created from a specific Bot.
- Use `bot_name` to search by Bot name using a contains match.
- Use `created_at_from` / `created_at_to` for inclusive task creation time bounds in ISO 8601 format.

### Pagination
Use `page` and `limit`. The response includes `total_pages` and `total_count`.

Normal Bot runs can include `bot_id` and `bot_name`. Official template runs omit template source fields and internal copied Bot IDs.



# Resume a paused task
Source: https://docs.browseract.com/workflow/api-reference/tasks/resume-a-paused-task

/openapi_3.json post /v3/bots/runs/{task_id}/resume
Requests the resumption of a paused Bot task. Agent bot tasks return error code `10879`; tasks that are not paused return `10127`. Resume is asynchronous, so the returned status can remain `paused` until processing continues.



# Retrieve a task
Source: https://docs.browseract.com/workflow/api-reference/tasks/retrieve-a-task

/openapi_3.json get /v3/bots/runs/{task_id}
Returns comprehensive information about a task, including its current `status`, accepted `input`, output, failure details, files, live browser information, and Bot step summaries when available.

Fields that do not apply to the run type or state are omitted. Official template runs do not expose template source fields or the internally copied Bot ID. If you only need the current status, use `GET /v3/bots/runs/{task_id}/status`.



# Retrieve a task status
Source: https://docs.browseract.com/workflow/api-reference/tasks/retrieve-a-task-status

/openapi_3.json get /v3/bots/runs/{task_id}/status
Returns the current public status and update time for a task. This endpoint is more lightweight than `GET /v3/bots/runs/{task_id}` and is recommended for polling.



# Run a bot (create a task)
Source: https://docs.browseract.com/workflow/api-reference/tasks/run-a-bot-create-a-task

/openapi_3.json post /v3/bots/{bot_id}/runs
Starts a new task execution for a published Bot and returns a `task_id`.

### How it works
1) Use `GET /v3/bots` to find a runnable Bot and copy its `bot_id`.
2) Use `GET /v3/bots/{bot_id}` to inspect its `input_schema`.
3) Provide an `input` object that conforms to that schema; use `{}` when no inputs are required.

### Webhooks
You can provide `callback_url` and/or `status_change_callback_url`. Both callbacks receive a complete `BotRunDetailResponse` without a data wrapper.



# Run an official bot template (create a task)
Source: https://docs.browseract.com/workflow/api-reference/tasks/run-an-official-bot-template-create-a-task

/openapi_3.json post /v3/bots/templates/{template_id}/runs
Starts a new task execution from an official Bot template and returns a `task_id`.

Use `GET /v3/bots/templates` to discover templates and `GET /v3/bots/templates/{template_id}` to inspect the template `input_schema`.

Provide an `input` object that conforms to the schema. Optionally select a `proxy_region` returned by `GET /v3/bots/regions`, and configure completion or status-change callbacks.

Template runs do not support the MCP execution context.



# Authentication & Credentials
Source: https://docs.browseract.com/workflow/help/authentication-and-credentials



### Credential Management Basics

**What is it?** A secure vault for storing login info (username, password, 2FA keys) that workflows use automatically.

**Why use it:**

* 🔒 End-to-end encrypted
* ⚡ One-click authorization
* 🛡️ Supports 2FA
* 📊 Complete usage logs

***

### Add Credentials

**Step 1:** Go to **Credential Center** → **Add**

<img alt="ac5e8e68-b5d3-4b74-9d6a-0d2eec0c5949.png" />

**Step 2:** Fill in basic info

* **Name:** e.g., "My Instagram Account"
* **Service:** e.g., "[instagram.com](http://instagram.com)"

**Step 3:** Add login fields

<img alt="60f44fb3-1a4d-453e-9100-3b93f3eb1c50.png" />

* Match what the website shows
* Example: Email = [your-email@gmail.com](mailto:your-email@gmail.com)
* Click **"Add Another Identifier"** if needed

<img alt="b5fcea19-84e3-4163-8198-83c5c860cb50.png" />

<img alt="c8b11e19-c790-4150-a3f4-349ffbd128b1.png" />

**Step 4 (optional):** Set up 2FA

* Get your Authenticator key from the website
* Paste into **2FA Key** field
* (Only Authenticator apps supported—email/SMS coming soon)

**Step 5:** Click **"Confirm"**

***

### Use Credentials in Workflows

**Method 1: From Credential Center**

1. Select credential → Click **"Authorize"**
2. Choose workflows to use it for
3. Click **"Authorize"** to confirm

<img alt="0aa189ce-85eb-4272-b36a-bcb5f7ba6a2c.png" />

**Method 2: From Workflow Settings**

1. Open workflow → **Start Node**
2. Enable **"Use Stored Credentials"**
3. Click **"Settings"** to add/select credentials

<img alt="3c22af16-f5dc-4e1c-8a81-a163bdd7236d.png" />

***

### Auto-Login Options

**Option A: Prompt each run**

* Best for: Different accounts each time
* How: Enable "Prompt for credentials"
* User enters login info when running workflow

<img alt="62bd3b2e-f89b-49ae-9e52-46ccfaab21b3.png" />

**Option B: Use stored credentials (recommended)**

* Best for: Automated/scheduled workflows
* How: Enable "Use stored credentials"
* Workflows auto-login without prompts

***

### What 2FA Is Supported?

**✅ Supported:**

* Authenticator apps (Google, Authy, Microsoft)

**📅 Coming soon:**

* Email verification codes
* SMS verification codes

***

### LinkedIn + 2FA Setup

**Complete walkthrough:**

1. **Enable 2FA on LinkedIn**
   1. Settings → Security → Two-factor authentication
   2. Choose Authenticator App
   3. LinkedIn generates QR code + secret key
2. **Copy your key**
   1. Copy the text key (below QR code)
   2. Keep it secure
3. **Add to BrowserAct**
   1. Credential Center → Add
   2. Name: LinkedIn
   3. Email: [your-email@gmail.com](mailto:your-email@gmail.com)
   4. Password: your-password
   5. 2FA Key: paste from LinkedIn
   6. Click **"Confirm"**
4. **Authorize credential**
   1. Credential Center → Select LinkedIn
   2. Click **"Authorize"** → Select workflows
   3. Click **"Authorize"** again
5. **Use in workflow**
   1. Open workflow → Start Node
   2. Enable **"Use Stored Credentials"**
   3. Select your LinkedIn credential
   4. Done! Auto-login works now ✅

***

### Troubleshooting: Login Fails

**Quick checklist:**  Start by verifying these common issues:

* Password has expired or been changed
* Account is locked or suspended
* Usename/email contains typos or extra spaces
* Two-factor authentication is not configured correctly

**Still stuck?** Contact us with: Task ID, error message, 2FA screenshot


# Best Practice
Source: https://docs.browseract.com/workflow/help/browser-configuration/best-practice



| **Scenario** | **Recommended Mode** | **Proxy Suggestion** | **Configuration Logic** | **Typical Examples** |
| :-: | :-: | :-: | :-: | :-: |
| **Social Media Account Management** | Standard Browser | Custom Proxy (Static IP) | Requires a persistent browser environment and login session. A stable, account-bound IP reduces re-authentication and lowers ban risk. | Reddit accounts<br />LinkedIn accounts<br />Instagram accounts |
| **E-commerce Price Comparison / Public Scraping** | Private Browser | BrowserAct Proxy (Rotating Residential) | Uses a clean environment on each run to avoid session tracking. IP rotation improves coverage while reducing overhead and proxy cost. | Amazon product listings <br />Walmart / Target pricing pages<br />Public e-commerce category pages |
| **SEO / Multi-region Search** | Private Browser | BrowserAct Proxy (Region-specific Residential) | Eliminates history and personalization bias. Region-based residential IPs return more accurate local search results. | Google Search (local SERPs)<br />Bing / DuckDuckGo results<br />Localized content visibility checks |
| **High-frequency Flash Sales** | Standard Browser | Custom Proxy (Static IP, Low Latency) | Maintains login state and cart/session continuity. Low-latency IPs reduce page load time and improve response speed. | Limited-edition product drops<br />Ticketing platforms<br />Time-sensitive checkout workflows |
| **Staging / QA Environment Testing** | Standard Browser | Custom Proxy (Static IP) | Test environments often whitelist IPs. Static IPs simplify access control, debugging, and reproducibility. | Staging dashboards<br />Pre-production admin panels<br />Internal QA tools |
| **Seller / Vendor Dashboard Automation** | Standard Browser | Custom Proxy (Static IP) | Marketplaces associate seller accounts with device and IP. Static IPs help maintain trust signals and session continuity. | Amazon Seller Central<br />Shopify Admin<br />App marketplace vendor dashboards |

### Key Rule of Thumb (Very Important)

> **If an account expects you to “look like the same user over time”, use Custom Proxy (Static IP)** **If the task only cares about “what the page shows right now”, use BrowserAct Proxy**

This single rule helps users self-select the correct setup.


# Browser Modes & Profiles
Source: https://docs.browseract.com/workflow/help/browser-configuration/browser-modes-profiles

This guide covers advanced browser controls for users running automation in production or at scale.

#### 1.Standard Browser

* **Positioning**  Designed to simulate **long-term, stable real-user behavior**.
* **How it works**

Each workflow is assigned a **fixed Browser ID**

Cookies, cache, and browsing history are automatically stored

The same browser environment is reused across runs

* Use **Standard Browser** when:
* **Your workflow requires logging into an account and staying logged in**  (e.g. dashboards, admin panels, social platforms)
* **The same workflow runs  repeatedly over time**  (daily, weekly, or event-triggered automation)
* **You want websites to see a consistent, returning user**  instead of a new visitor on every run
* **Session stability matters more than anonymity**  (fewer re-logins, fewer verification prompts)

**Not recommended for**

* High-frequency account switching
* Strong anonymity or one-off scraping tasks

<img alt="Image" />

#### 2.Private Browser

* **Positioning**  Designed for **fully isolated, temporary browser environments**.
* **How it works**

Each run starts with a clean browser instance

No cookies, cache, or browsing history are saved

Browser data is destroyed after the task completes

Use **Private Browser** when:

* **You are scraping or browsing public pages without login**  (search results, product listings, content pages)
* **Each run should be fully isolated from previous runs**  (no cookies, no session reuse)
* You want to avoid cross-session tracking or data accumulation
* You are testing multiple scenarios where persistence is unnecessary

**⚠️ Switching Reminder**: When switching from Standard Mode to Private Mode, the system will prompt: **"Historical browser data will be cleared."**


# How to Use BrowserAct Proxies
Source: https://docs.browseract.com/workflow/help/browser-configuration/how-to-use-browseract-proxies

Choose Static Proxy or Dynamic Proxy for BrowserAct browsers and workflows.

## Introduction

BrowserAct offers two proxy modes:

<Columns>
  <Card title="Static Proxy" icon="shield-check">
    Keeps the same IP across sessions.
  </Card>

  <Card title="Dynamic Proxy" icon="refresh-cw">
    Rotates IPs between sessions.
  </Card>
</Columns>

In BrowserAct, the proxy mode is usually paired with a browser environment:

<Columns>
  <Card title="Static Proxy + Standard Browser" icon="monitor-check">
    Use Static Proxy when you need a stable identity.
  </Card>

  <Card title="Dynamic Proxy + Private Browser" icon="shield">
    Use Dynamic Proxy when you need a rotating identity.
  </Card>
</Columns>

## Detail

### 1. Choose the right proxy mode

| Mode | Browser environment | Best for |
| - | - | - |
| Static Proxy | Standard Browser | Account management, long-lived logins, social media operations, e-commerce allowlisting, fixed-IP workflows |
| Dynamic Proxy | Private Browser | Web scraping, price monitoring, anti-tracking, ad verification, rotating-IP workflows |

### 2. Use Static Proxy with CLI and Standard Browser

Use Static Proxy when you want to bind one proxy to one Browser or extraction task.

#### Create a browser with Static Proxy

```bash theme={null}
browser-act browser create --type stealth --name "<browser-name>" --desc "<browser-description>" --static-proxy <static-proxy-id>
```

#### Create a private-mode browser with Static Proxy

```bash theme={null}
browser-act browser create --type stealth --name "<browser-name>" --desc "<browser-description>" --mode private --static-proxy <static-proxy-id>
```

#### Update an existing browser with Static Proxy

```bash theme={null}
browser-act browser update <browser-id> --static-proxy <static-proxy-id>
```

#### Remove browser proxy

```bash theme={null}
browser-act browser update <browser-id> --no-proxy
```

#### Use Static Proxy during extraction

```bash theme={null}
browser-act stealth-extract "<url>" --static-proxy <static-proxy-id>
```

#### Extract and save the result

```bash theme={null}
browser-act stealth-extract "<url>" --static-proxy <static-proxy-id> --output <output-file>
```

#### Recommended flow

1. Buy a Static Proxy and copy its `static-proxy-id`.
2. Bind the proxy when you create or update a Browser.
3. Launch the Browser in **Standard Browser** mode.
4. Keep the same proxy bound to the same account or workflow whenever possible.

### 3. Use Dynamic Proxy with Private Browser

Dynamic Proxy is configured at the browser setting level.

#### For a Browser session

1. Open **BrowserAct Proxy Settings**.
2. Switch the browser mode to **Dynamic Proxy**.
3. Choose the region you want to use.
4. Save the setting and launch the browser in **Private Browser** mode.

#### For a workflow

1. Open **Workflow Browser Settings**.
2. Select **Dynamic Proxy**.
3. Choose the region.
4. Save the setting.
5. All browser tasks in that workflow will use the selected Dynamic Proxy configuration.

### 4. Use Static Proxy in Workflow

1. Open **Workflow Browser Settings**.
2. Select **Static Proxy** as the browser proxy type.
3. Choose a proxy from the **Select Static Proxy** list.
4. Save the setting.
5. All browser tasks in that workflow will use the selected Static Proxy automatically.

### 5. Business scenarios

The easiest way to choose a proxy is to match the proxy mode with the browser environment and the task goal.

#### Static Proxy + Standard Browser

Use this combination when stability matters more than rotation.

Typical scenarios:

* Account management
* Social media operations
* E-commerce operations
* Long-lived login sessions
* API allowlisting with a fixed IP

Why this combination works:

* Static Proxy keeps the IP stable across sessions.
* Standard Browser gives the task a consistent browser environment.

#### Dynamic Proxy + Private Browser

Use this combination when rotation and session isolation matter more than stability.

Typical scenarios:

* Web scraping
* Price monitoring
* Anti-tracking tasks
* Ad verification
* Other tasks that do not depend on a fixed IP

Why this combination works:

* Dynamic Proxy gives you a rotating IP.
* Private Browser keeps the browsing session isolated.

#### Quick decision guide

<Columns>
  <Card title="Stable IP" icon="fingerprint">
    Need a stable IP for one account or workflow? Use **Static Proxy + Standard Browser**.
  </Card>

  <Card title="Rotating IP" icon="refresh-cw">
    Need a rotating IP for extraction or monitoring? Use **Dynamic Proxy + Private Browser**.
  </Card>

  <Card title="Shared workflow IP" icon="workflow">
    Need all tasks in one workflow to share the same IP? Bind a Static Proxy at the workflow level.
  </Card>
</Columns>

### 6. Tips

* Use Static Proxy for account-sensitive tasks.
* Use Dynamic Proxy for high-volume or scraping-heavy tasks.
* Avoid switching proxy mode too often for the same account unless you have a clear reason.
* If the proxy you need is not listed, contact support on [Discord](https://discord.com/invite/UpnCKd7GaU).


# Performance & Browser Maintenance
Source: https://docs.browseract.com/workflow/help/browser-configuration/performance-browser-maintenance

This section helps you optimize performance and maintain browser state in minutes, for advanced automation and production workflows.

### 1 Performance Optimization

#### **Block Ads**

**Purpose**

* Blocks banner ads and pop-ups
* Improves page load speed

**Enable when**

* Pages contain heavy advertising
* Ads are irrelevant to your data collection
* Running high-frequency or large-scale workflows

***Note***\*:\****Off by default*** *, can be enabled if needed.*

<img alt="Image" />

### 2 Browser Maintenance Tools

This action is only supported in Standard Browser mode.

#### 2.1 Clear Browser Data

* Manually clears cookies, cache, and browsing history
* **Browser fingerprint remains unchanged**
* Click the bottom left corner of the page -**Clear Browser Data**- and confirm again

<img alt="Image" />

<img alt="Image" />

⚠️ **Limitation**  This action is disabled while a task is running. BrowserAct will block the operation and show an error message.

<img alt="Image" />

#### **2.2 Get New Fingerprint**

  **What happens**

* Generates a completely new browser fingerprint
* Includes WebRTC, WebGL, and WebGPU parameters
* Websites will recognize the browser as a **new device**

<img alt="Image" />

<img alt="Image" />


# Proxy & Network Settings
Source: https://docs.browseract.com/workflow/help/browser-configuration/proxy-network-settings

BrowserAct provides flexible proxy and network options to support both out-of-the-box usage and custom proxy integrations, depending on your workflow requirements.

#### 1.BrowserAct Proxy

**Key benefits**

* Built-in global residential proxy pool
* IP is automatically rotated on each run
* No credentials or manual configuration required

Use **BrowserAct Proxy** when:

* You want to get started quickly without managing proxy infrastructure
* Your workflow needs IP rotation on each run by default
* You are accessing region-specific content  (localized search results, country-based pricing, geo-restricted pages)
* You prefer residential IPs with minimal configuration

#### 2. Custom Proxy

**Best suited for**

* Users with existing third-party proxy providers
* A specific IP must stay bound to an account or session

**Configuration steps**

* Select `Custom Proxy`
* Click `+ Add Proxy`

<img alt="Image" />

* Enter protocol (HTTP / SOCKS5), server address, port, and credentials

<img alt="Image" />

* Click `Proxy Check` to validate the proxy

<img alt="Image" />

* **Click confirm**

<img alt="Image" />

After confirmation, the proxy will appear in the list, allowing for editing or deletion at any time.

**Why Proxy Check matters**

* Ensures the proxy is reachable
* Displays the outbound IP and detected region
* Prevents invalid proxies from being used in execution


# Quick Start
Source: https://docs.browseract.com/workflow/help/browser-configuration/quick-start

This guide helps you configure BrowserAct’s browser settings in under 3 minutes for most common automation scenarios.

<iframe title="YouTube video player" />

### **1. Open Browser Settings**

To access browser configuration:

* Open the **Start** node in the workflow editor
* Locate **Default Browser Settings** at the bottom of the Start node
* Click **Settings** to open the browser configuration panel

<img alt="Image" />

<img alt="Image" />

### **2. Choose Browser Mode**

Select how BrowserAct manages browser data and sessions for your workflow.

#### **Standard Browser（ Default）**

**Persistent browser sessions** across runs

Each workflow gets a **dedicated and stable browser environment**

Cookies, cache, and login state are automatically preserved

**Best for**

* Logged-in accounts
* Long-running automation tasks

<img alt="Image" />

#### **Private Browser**

Use **Private Browser** only if:

* You are scraping public pages
* Logging is not required
* Each run should start with a clean environment

Private Browser runs in incognito mode and does not save any data after execution.

<img alt="Image" />

### **3. Configure Proxy**

BrowserAct supports **two proxy options**, allowing you to control IP location and network identity.

* **BrowserAct Proxy:**

**Fastest and easiest option**

* Built-in **global residential proxy network**
* Automatically assigns a new IP on each run
* Select a country or region directly — no manual setup required

<img alt="Image" />

**Custom Proxy:**

Use this only if you already have your own proxy service.

* Add your preferred HTTP or SOCKS5 proxy
* Supports authentication and custom endpoints
* Includes **Proxy Check** to validate connectivity before running tasks

<img alt="Image" />

### [**4.Save**](http://4.Save) Your Settings

After completing your configuration, \*\*always click \*\*`Save` in the bottom-right corner to apply changes.

Unsaved settings will not take effect.

### One-line takeaway

> **Standard Browser + BrowserAct Proxy → Save → Run.**

You’re ready to execute your workflow.


# Troubleshooting
Source: https://docs.browseract.com/workflow/help/browser-configuration/troubleshooting

This will help you quickly diagnose and resolve browser configuration–related issues.

### **1. “Clear Browser Data” Is Disabled**

**Cause**

* A workflow task is currently running

**Solution**

* Stop the running task
* Retry after the task completes

<img alt="Image" />

### 2.Proxy Check Failed

* Incorrect proxy credentials
* Wrong proxy protocol
* Proxy IP is blocked or unavailable

**Troubleshooting steps**

Verify proxy username and password

Confirm protocol (HTTP or SOCKS5)

Try a different proxy endpoint

<img alt="Image" />

### 3.Detected Proxy Region Does Not Match Expectations

**Cause**

* Inaccurate geo metadata from the proxy provider

**Solution**

* Manually edit the `Region` field
* Save settings and continue execution

<img alt="Image" />

### 4.Frequent Login or Verification Prompts When Running the Workflow

**Possible reasons**

* Using Private Browser for login-based workflows
* Fingerprint is being reset too often

**Recommended fixes**

* Switch to Standard Browser
* Use a stable Custom Proxy
* Avoid unnecessary fingerprint regeneration


# Billing & Credits
Source: https://docs.browseract.com/workflow/help/credits-subscription/billing-credits



### How Credits Work

**Basic formula:** 1 action = 5 credits

**Standard actions (5 credits each):**

* Navigate to page
* Click element
* Input text
* Extract data
* Wait for element
* Go back
* Scroll

**Special actions:**

* Loop: loop count × 5
* Loop List: item count × 5
* Scroll to element: scroll count × 5

***

### Credit Deduction Priority

**Your credits used in this order:**

1. **Daily Bonus** (used first)
   1. Earned via daily login
   2. Valid today only (resets at 00:00)
2. **Monthly Credits** (used second)
   1. From subscriptions/AppSumo
   2. Valid current month only
3. **Permanent Credits** (used last)
   1. From top-ups/rewards
   2. Never expire

Why? To minimize waste of your most valuable credits.

***

### Claim Daily Credits

**Free users:**

* Log in daily
* Go to **Balance** card (bottom left)
* Click **"Claim Daily Credits"**

**Paid users:**

* Auto-receive 500 credits daily at 00:00 AM (your timezone)
* No action needed!

⏰ Remember: Daily credits expire at 00:00 AM next day—use them!

***

### Payment Methods

✅ PayPal

✅ Stripe (credit/debit cards)

**Enterprise?** Need invoicing or special terms? [Contact sales](https://discord.com/invite/UpnCKd7GaU)


# Credit Packs
Source: https://docs.browseract.com/workflow/help/credits-subscription/credit-packs

Run out of credits before your monthly cycle ends? Credit Packs allow you to add extra credits to your account instantly without changing your current plan.

## 1. Eligibility

Credit Packs are designed as supplementary resources for our active users. To purchase a Credit Pack, you must meet one of the following conditions:

* You have an **active subscription** (Monthly or Yearly Plan).
* You are a **Lifetime Deal (LTD)** holder.

*Note: Credit Packs are not available for users on the Free Plan.*

## 2. Expiration & Reset Policy (Important!)

All credits from a Credit Pack are **strictly tied to your current Monthly Cycle.**

* **The Rule:** All credits from a Credit Pack **expire and reset to zero** at the end of your current monthly cycle. They do **not** roll over to the next month.
* **Synchronization:** Regardless of whether you are on a Monthly or Yearly plan, the expiration date of your Credit Pack is exactly the same as your next **monthly credit reset date**.

> #### ⚠️ Critical Example:
>
> If your current monthly cycle is set to reset on **Jan 15th**:
>
> * If you buy a Credit Pack on **Jan 1st**, you have 14 days to use those credits.
> * If you buy a Credit Pack on **Jan 14th**, those credits will **expire in 24 hours** on Jan 15th.

## 3. Double Confirmation

To prevent accidental purchases or misunderstandings regarding the expiration date:

* A **confirmation pop-up** will appear before you complete your purchase.
* This pop-up will explicitly state the expiration date of the credits you are about to buy. Please review this information carefully before proceeding.

4. Refund Policy

All Credit Pack purchases are **final and non-refundable**, regardless of whether the credits were used before the monthly cycle reset.


# Subscription & Management
Source: https://docs.browseract.com/workflow/help/credits-subscription/subscription-management

Welcome to our subscription guide. This article explains how our plans work, how credits are allocated, and how you can manage your subscription settings.

## 1. Choosing Your Plan

We offer two billing cycles to suit your needs:

* **Monthly Subscription:** Full flexibility, billed on a recurring monthly basis.
* **Yearly Subscription:** Best value, billed annually (Includes a 20% discount compared to monthly billing).

> **Note:** All prices are billed in USD.

## 2. Credit Allocation & Reset Policy

To ensure a consistent experience, credits are distributed based on your **Monthly Billing Cycle**, regardless of whether you are on a Monthly or Yearly plan.

* **Distribution:** Credits are automatically added to your account at the start of each billing month.
* **No Roll-over Policy:** All unused credits **expire at the end of each billing cycle** and do not roll over to the next month.
* **Reset Logic:** Your credits reset on the same date each month.
  * **Example:** If you subscribed on **Jan 15th**, your current cycle ends on **Feb 14th at 23:59:59 (UTC)**. Your new credits will be issued, and the previous balance will reset, on **Feb 15th at 00:00:00 (UTC)**.

## 3. Managing Your Subscription

You have full control over your subscription through your dashboard.

#### How to Cancel

If you wish to stop your subscription, follow these steps:

1. Navigate to **Plan & Billing**.
2. Go to the **Subscription** section.
3. Click **Cancel Subscription** and follow the confirmation prompts.

#### What happens after I cancel?

* **Current Benefits:** You will retain access to all features and your remaining credits until the **end of your current billing cycle**.
* **Auto-Renewal:** Your subscription will not renew once the current period expires.
* **Account Status:** After the cycle ends, your account will automatically revert to the Free Tier.

## 4. Refund Policy

Please note that all subscription payments are **non-refundable**. We recommend exploring our Free Plan or starting with a Monthly Plan to ensure our service meets your requirements before committing to a longer term.


# Upgrade Your Plan
Source: https://docs.browseract.com/workflow/help/credits-subscription/upgrade-your-plan

Need to boost your account? You can upgrade your plan at any time. This guide explains the two types of upgrades and how the costs and credits are handled.

## 1. Upgrade Options & Timing

We offer two ways to upgrade your plan depending on when you want the new benefits to start:

#### Option A: Immediate Upgrade

* **Availability:** This option is available if there are **more than 48 hours remaining** in your current billing month.
* **How it works:** Your new features and the credit difference are unlocked **instantly**.
* **Billing:** You pay the **fixed price difference** between your current plan and the new plan.
* **Cycle Rule:** Your original billing cycle remains unchanged.

#### Option B: Next Cycle Upgrade

* **Availability:** Available at any time during your subscription. (Note: If you are within **48 hours** of your billing cycle end date, this is the only available option).
* **How it works:** You continue with your current plan until the end of the current cycle. The new plan and its full credits will activate automatically on your **next billing date**.
* **Billing:** You will be charged the **full price** of the new plan immediately to schedule the upcoming cycle.

## 2. Cost & Credit Examples

#### Example: Immediate Upgrade

If you are currently on a **\$10/month** plan (100 credits) and upgrade to a **\$30/month** plan (500 credits):

* **Payment:** You pay a flat difference of **\$20** immediately.
* **Credits:** You receive the difference of **400 credits** instantly.
* **Cycle:** If your cycle was set to end on the 15th, it **remains the 15th**. You do not get a "fresh month"; you simply boost your current month's capacity.

#### Example: Next Cycle Upgrade

If you choose to have the **\$30/month** plan start from the next period:

* **Payment:** You pay **\$30** today.
* **Activation:** You stay on your \$10 plan for the rest of this cycle. On your next billing date, your account will refresh with the full 500 credits of the new plan.

## 3. Switching from Monthly to Yearly

Directly switching from a Monthly plan to a Yearly plan is not supported at this time.

**To switch to a Yearly plan:**

1. Navigate to **Plan & Billing** and **Cancel** your current Monthly subscription.
2. Once canceled, you can immediately select and purchase a **Yearly Plan**.
3. **Activation:** The Yearly Plan will be scheduled to start automatically **at the beginning of your next billing cycle**, ensuring no interruption to your service.


# Frequently Asked Questions
Source: https://docs.browseract.com/workflow/help/frequently-asked-questions



**Q: Can I extract more than 1,000 records?**

A: Technically yes, but not recommended. Split large jobs into smaller Bot runs. If the job needs to repeat automatically, create separate BrowserAct schedules for each input set.

**Q: What's the actual maximum?**

A: No hard cap, but stability issues appear >10K records. Stick to \<1K per run.

**Q: Can I use my own LLM model?**

A: Not currently. We use an AI engine optimized specifically for web automation.

**Q: Can a credential be shared across workflows?**

A: Yes! Assign one credential to unlimited workflows from Credential Center.

**Q: Is 2FA required?**

A: No, but highly recommended for security.

**Q: Are my credentials secure?**

A: Yes. End-to-end encrypted, visible only to you. No third-party access.

**Q: What if I change my password on a website?**

A: Update it in Credential Center. Go to Edit → Update password → Save.

**Q: Can I export my workflows?**

A: Yes, as JSON files. Great for sharing and backups.

**Q: How do I cancel a running task?**

A: Dashboard → Activity Log → Click task → **"Cancel"** button


# API Keys & Authentication
Source: https://docs.browseract.com/workflow/help/integrations-apis/api-keys-authentication



### Get Your API Key

1. **Dashboard** → **Integrations & API**
2. Click **"Create New API Key"**
3. Copy and use it

***

### API Specs

**No rate limits**

**Task limits:**

* Free users: 1 task per run
* Paid users: 20 concurrent tasks

**Session duration:** Max 7 hours per task

**Webhook support:**

* Triggered on: completion, failure, cancellation
* Must respond within 30 seconds
* Auto-retries on 5xx errors (max 3 times)


# How to Importing Data to Google Sheets
Source: https://docs.browseract.com/workflow/help/integrations-apis/how-to-import-data-to-google-sheets

This tutorial shows how to automatically import data extracted by BrowserAct to Google Sheets via Make.com.

### Prerequisites

**1.Ensure Data Format is JSON**  In BrowserAct workflow's Output Data node, ensure format is set to JSON.

**2.Prepare Google Sheets**

* Create new Google Sheets
* Set column headers (matching extracted data fields)
* Note Sheet name and ID

### [Make.com](http://Make.com) Integration Steps

#### **Step 1: Create Make Scenario**

Log in to [Make.com](http://Make.com) and Click "Create a new scenario"

<img alt="image (6).png" />

#### **Step 2: Add BrowserAct Module**

**2.1 Add Module**

1. Click + to add module
2. Search "BrowserAct"
3. Select "Run a workflow"

**2.2 Configure BrowserAct Connection**

1. Click "Add" to create a new connection
2. Enter your BrowserAct API Key
3. Click "Save"

**2.3 Select Workflow**

1. Select your workflow from the dropdown
2. Configure required input parameters (if any)
3. Click "OK"

⚠️ Important: Ensure your BrowserAct workflow output format is JSON

<img alt="image (7).png" />

#### **Step 3: Set Up JSON Processing**

**3.1 Add JSON Module**

1. Click + to add new module
2. Search "JSON"
3. Select "Parse JSON"

**3.2 Configure JSON Parser**

Generate data structure:

1. Open BrowserAct，go to workflow execution history (Activity log)，find successful execution record
2. Copy complete JSON output data
3. Return to [Make.com](http://Make.com)，In JSON Parse module, click "Generate"
4. Paste copied JSON data into "Sample data" field, click "Save"

<img alt="image (8).png" />

**Configure JSON string field:**

1. In "JSON string" field
2. Click to select BrowserAct module output
3. Select field containing data (usually output.string)

<img alt="image (9).png" />

#### **Step 4: Connect Google Sheets**

**4.1 Add Google Sheets Module**

1. Click + to add a new module. Search "Google Sheets"- "Add a Row"
2. **Configure Google Sheets Connection**

* Click "Add" to create a new connection
* Authorize [Make.com](http://Make.com) to access your Google account
* Select target Google Sheets
* Select target Sheet (worksheet)

<img alt="image (10).png" />

**4.2 Map Data Fields**

Important concepts:

* **Columns:** Define Google Sheets column order
* **Values:** Map data to corresponding columns

<img alt="image (11).png" />

#### **Step 5: Test Run**

**5.1 Run Test**

1. Click "Run once" at bottom
2. Observe execution process
3. Check output of each module

<img alt="image (12).png" />

**5.2 Verify Results**

1. Open your Google Sheets
2. Confirm data added correctly
3. Check data format and content

**5.3 Handle Multiple Records**

**<u>If your BrowserAct workflow returns multiple records (array),you need to additerators :</u>**

**Configure iterator:**

1. Add Iterator module between JSON Parse and Google Sheets
2. Select array field from JSON Parse output
3. Each iteration automatically adds rows to Google Sheets

### Common Troubleshooting

**Issue 1: JSON Parse Failed**  Error: Invalid JSON

Solutions:

1. Confirm BrowserAct output format is JSON
2. Check JSON data is complete

**Issue 2: Field Mapping Error**  Error: Field not found

Solutions:

1. Re-generate JSON data structure
2. Confirm field names match exactly
3. Check case sensitivity

**Issue 3: Data Not Added to Sheets**  Possible causes:

* Google Sheets connection expired
* Sheet name changed
* Insufficient permissions

Solutions:

1. Re-authorize Google Sheets connection
2. Confirm Sheet name and ID correct
3. Check Google account permissions

Expected results:

* ✅ Data automatically transfers from BrowserAct to Google Sheets
* ✅ New row added each run
* ✅ Data format correct, fields correspond


# How to Set Up Scheduled Runs for BrowserAct
Source: https://docs.browseract.com/workflow/help/integrations-apis/how-to-set-up-scheduled-tasks-for-browseract

Choose BrowserAct schedules or Make.com scheduling to run BrowserAct automatically.

### Why Scheduled Tasks?

BrowserAct now supports native Bot schedules for published Bots. Use BrowserAct schedules when you want BrowserAct to run a Bot automatically and email results from inside BrowserAct.

See [Schedule Bot Runs](/bot/schedules/schedule-bot-runs) for the native BrowserAct setup.

Use Make.com scheduling when the scheduled run should continue into Make modules such as Google Sheets, Airtable, Slack, email, a database, or another downstream workflow.

Common use cases:

* 📊 Price monitoring - Scrape competitor product prices daily
* 📰 Brand monitoring - Monitor social media brand mentions hourly
* 📈 Market analysis - Auto-generate industry data reports weekly
* 📦 Inventory tracking - Check target product stock daily
* ✍️ Content updates - Regularly scrape latest articles from news sites

### Basic Concepts

BrowserAct schedules can run published Bots by hour, day, or week, with BrowserAct result email options and retry settings.

[**Make.com**](http://Make.com)\*\* Scheduled Triggers\*\*  [Make.com](http://Make.com) provides flexible scheduling features for external automation scenarios that can:

* ✅ Run at fixed intervals (hourly, daily, etc.)
* ✅ Run at specific times (every day at 8:00 AM)
* ✅ Run on specific dates (every Monday at 9:00 AM)
* ✅ Custom Cron expressions (advanced users)

### Quick Start: 3 Steps to Set Up Make Scheduled Tasks

#### **Step 1: Create Make Scenario**

1. Log in to [Make.com](http://Make.com)
2. Create a new Scenario
3. Name scenario (e.g., "Daily Price Monitor")

<img alt="image (3).png" />

#### **Step 2: Add BrowserAct Module as First Module**

**2.1 Add Module**

1. Click + to add module
2. Search "BrowserAct"
3. Select "Run a workflow"

**2.2 Configure BrowserAct**

1. Connect your BrowserAct account
2. Select workflow to run
3. Configure input parameters (if any)

⚠️ Important: Ensure workflow output format is JSON for subsequent processing

<img alt="image (4).png" />

#### **Step 3: Add Scheduled Trigger for BrowserAct**

**3.1 Add Schedule**

1. Click clock icon on BrowserAct module
2. Select "Scheduling"

**3.2 Configure Run Frequency**

<img alt="image (5).png" />

**Option A: Fixed Intervals**  Example configurations:

* Every 1 hour
* Every 6 hours
* Every 1 day

**Option B: Specific Times**  Example configurations:

* Every day at 8:00 AM
* Every day at 6:00 PM

**Option C: Specific Dates and Times**  Example configurations:

* Every Monday at 9:00 AM
* Every 1st of month at 10:00 AM
* On weekdays at 8:00 AM

**3.3 Save Settings**

1. Confirm schedule configuration
2. Click "OK" to save
3. Activate scenario (turn on switch in top right)

Your BrowserAct workflow is now scheduled to run automatically from Make. [Make.com](http://Make.com) will trigger it according to your configured schedule.

**Want to Do More with Your Data?**

Don't stop here! You can add more modules after BrowserAct to:

* **Send email notifications** with scraped data
* **Save to Google Sheets** for tracking and analysis
* **Store in databases** like Airtable or MySQL
* **Send Slack/Discord alerts** when conditions are met
* **Trigger other workflows** based on results

Simply click the **+** button after your BrowserAct module to explore hundreds of available integrations.

### **Next Steps:**

* For native BrowserAct schedules, review the schedule list in the Bot's `Schedules` tab
* For Make scheduled scenarios, monitor runs in [Make.com](http://Make.com)'s execution history
* Check BrowserAct's Activity Log to verify completions
* Join Discord for automation ideas and support


# How to Share and Use Workflows in Make Using JSON Files
Source: https://docs.browseract.com/workflow/help/integrations-apis/how-to-share-and-use-workflows-in-make-using-json-files

This beginner's guide will show you how to import and export workflows in Make using JSON files, making it easy to share your automation workflows with others.

### Importing a JSON Workflow into Make

Follow these steps to import a workflow blueprint from a JSON file:

### **Step 1: Log in to Make**

* Access your Make account at [make.com](http://make.com) and sign in with your credentials.

### **Step 2: Create a New Scenario**

* Navigate to "Scenarios" in the left sidebar
* Click on "Create a new scenario" button

<img alt="Download Image(8) Pn" />

### **Step 3: Import the Blueprint**

* Look at the bottom of the canvas and click the "..." (three dots) button labeled "more"
* Select "Import Blueprint" from the dropdown menu
* Browse your computer and select the JSON workflow file you want to import
* Click "Save" to confirm

<img alt="Download Image(9) Pn" />

<img alt="Download Image(2) Pn" />

### **Step 4: Configure Your Workflow**

* Once imported, review all the modules (nodes) in your workflow
* Complete any necessary configuration for each module, such as connecting accounts, setting parameters, or filling in required fields
* Test your scenario to ensure everything works correctly
* Save and activate your scenario when ready

<img alt="Download Image(3) Pn" />

### Exporting Your Workflow as a JSON File

To share your workflow with others, you can export it as a JSON file:

### **Step 1: Open Your Scenario**

* Go to the scenario you want to export

### **Step 2: Export the Blueprint**

* Click the "..." (three dots) button at the bottom of the canvas
* Select "Export Blueprint" from the menu
* The JSON file will be downloaded to your computer

### **Step 3: Share Your Workflow**

* You can now share this JSON file with team members, clients, or the Make community
* Recipients can import it following the import instructions above

### Tips for Success

* Always review imported workflows before activating them
* Update any connection credentials and API keys after importing
* Add comments or documentation to help others understand your workflow
* Keep your exported JSON files organized with clear naming conventions

That's it! You now know how to import and export workflows in Make, making collaboration and workflow sharing simple and efficient.


# How to Share and Use Workflows in n8n Using JSON Files
Source: https://docs.browseract.com/workflow/help/integrations-apis/how-to-share-and-use-workflows-in-n8n-using-json-files

This beginner-friendly guide will walk you through the process of importing and exporting workflows in n8n using JSON files, enabling seamless workflow sharing and collaboration.

### Importing a JSON Workflow into n8n

Follow these simple steps to import a workflow from a JSON file:

**Step 1: Log in to n8n**

* Access your n8n instance (either cloud or self-hosted)
* Sign in with your credentials

### **Step 2: Create a New Workflow**

* Click on "Create Workflow" button
* This will open a blank workflow canvas

<img alt="download_image (4).png" />

### **Step 3: Import the JSON File**

* Look for the "..." (three dots) menu button, typically located in the top-right corner
* Click on it and select "Import from File" from the dropdown menu
* Browse your computer and select the JSON workflow file you want to import
* The workflow will be loaded onto your canvas

<img alt="download_image (5).png" />

### **Step 4: Configure the Workflow**

* Review all the nodes in the imported workflow
* Follow any prompts or instructions provided by the workflow
* Configure necessary credentials, API connections, and parameters for each node
* Set up any required authentication or account connections
* Test your workflow to ensure it functions correctly
* Save and activate the workflow when ready

<img alt="download_image (6).png" />

### Exporting Your Workflow as a JSON File

To share your n8n workflow with others, export it as a JSON file:

### **Step 1: Open Your Workflow**

* Navigate to the workflow you want to export

### **Step 2: Download the JSON File**

* Click the "..." (three dots) menu button
* Select "Download" from the dropdown menu
* The workflow JSON file will be downloaded to your computer automatically

### **Step 3: Share Your Workflow**

* Share the downloaded JSON file with colleagues, team members, or the n8n community
* Recipients can import the file using the import steps outlined above

### Best Practices

* **Review before activating**: Always check imported workflows thoroughly before running them in production
* **Update credentials**: Remember to reconfigure all authentication and API credentials after importing
* **Test thoroughly**: Run test executions to verify the workflow operates as expected
* **Document your workflows**: Add notes within your workflow to help others understand its purpose and configuration
* **Organize your files**: Use descriptive file names when saving JSON exports (e.g., "customer-onboarding-workflow\.json")
* **Version control**: Consider keeping multiple versions of your workflows as you make improvements

### Troubleshooting Tips

* If a workflow fails after import, check that all required nodes and integrations are available in your n8n instance
* Ensure you have the necessary permissions and API access for third-party services used in the workflow
* Review the execution logs to identify any configuration issues

That's all there is to it! You can now easily import and export workflows in n8n, making it simple to share automation solutions and collaborate with others.

<img alt="download_image (7).png" />


# Make & n8n Integrations
Source: https://docs.browseract.com/workflow/help/integrations-apis/make-n8n-integrations



**Import Data to Google Sheets**

[******Via Make.com (easiest):******](http://Make.com)

1. Create Make scenario
2. Add BrowserAct module (Run workflow)
3. Connect BrowserAct account + select workflow
4. Add JSON Parse module
5. Add Google Sheets "Add Row" module
6. Map fields to columns
7. Test → Save

→ [Detailed walkthrough](https://docs.browseract.com/workflow/help/integrations-apis/how-to-import-data-to-google-sheets)

***

**Schedule Automated Runs**

Use [BrowserAct schedules](/bot/schedules/schedule-bot-runs) when you want BrowserAct to run a published Bot automatically and email results from inside BrowserAct.

[******Use Make.com scheduling:******](http://Make.com)

Use Make.com scheduling when the scheduled Bot run should continue into Make modules such as Google Sheets, Airtable, Slack, email, a database, or another downstream workflow.

1. Create scenario with BrowserAct module
2. Click clock icon → **"Scheduling"**
3. Pick frequency:
   1. Every 1 hour / 6 hours / day
   2. Every day at 8:00 AM
   3. Every Monday at 9:00 AM
   4. Custom cron expressions
4. Save & activate

**Examples:**

* 📊 Price monitoring – Daily at 8 AM
* 📰 Brand monitoring – Every 6 hours
* 📈 Reports – Every Monday 9 AM

→ [Native BrowserAct scheduling guide](https://docs.browseract.com/bot/schedules/schedule-bot-runs)

→ [Make scheduling guide](https://docs.browseract.com/workflow/help/integrations-apis/how-to-set-up-scheduled-tasks-for-browseract)

***

**Share Workflows as JSON**

**Export workflow:**

1. Open scenario
2. Click "..." → **"Export Blueprint"**
3. JSON file downloads
4. Share with others

**Import workflow:**

1. Create new scenario
2. Click "..." → **"Import Blueprint"**
3. Select JSON file
4. Configure modules
5. Test & activate

Works in Make and n8n.

→ [Full scheduling guide](https://docs.browseract.com/workflow/help/integrations-apis/how-to-share-and-use-workflows-in-n8n-using-json-files)


# Supported Platforms
Source: https://docs.browseract.com/workflow/help/integrations-apis/supported-platforms



### Supported Platforms

**Official integrations:**

✅ [Make.com](http://Make.com) (native node)  ✅ n8n (cloud node)  ✅ REST API (any platform)

📅 **Coming:** Zapier native integration

Other platforms? Use our [REST API](https://www.browseract.com/reception/integrations/api-workflow)


# How to Become a BrowserAct Creator: A Step-by-Step Guide
Source: https://docs.browseract.com/workflow/help/resources-support/step-by-step-tutorial-to-publish-workflows

This guide walks you through the entire process of becoming a BrowserAct Creator, publishing workflows and earning rewards for your contributions.

## ✅ **1. Open the Creator Plan Page**

1. Log in to your [**BrowserAct Dashboard.**](https://www.browseract.com/reception)
2. From the left menu, click **“Creator Plan”.** You’ll see the **application form** here.

<img alt="image.png" />

***

## ✅ **2. Apply to Become a Creator**

1. Fill in the required details:
   1. Your **name** and **email address**
   2. **Social media links** (e.g., Twitter, YouTube, LinkedIn)
   3. A short summary of what kind of workflows or content you create
2. Click **“Submit Application.”**
3. The BrowserAct team will review your submission within **48 hours** and notify you by email once it’s approved.

<img alt="PixPin_2025-12-12_17-13-45.png" />

***

## ✅ **3. Access Publish Management**

* Once your application is approved, **“Creator Plan”** in the sidebar will automatically change to **“Publish Management.”**
* This is your **creator dashboard**, where you can manage and publish all of your workflow templates.

<img alt="PixPin_2025-12-12_17-14-11.png" />

***

## ✅ **4. Choose What to Publish**

Inside **Publish Management**, you’ll see two publishing options:

| **Option** | **Description** |
| :-: | :-: |
| **Publish from Workflow** | Publish a BrowserAct workflow directly |
| **Publish Make/n8n Template** | Publish a Make or n8n workflow template |

<img alt="PixPin_2025-12-12_17-14-35.png" />

***

## ✅ **5. Publish a BrowserAct Workflow**

1. Click **“Publish from Workflow.”**
2. Choose an existing workflow from the list or create a new one.

<img alt="PixPin_2025-12-12_17-15-15.png" />

Fill in the details — template name, category, tags, and a short description.

4. Click **“Submit Review.”**

<img alt="PixPin_2025-12-12_17-15-52.png" />

***

## ✅ **6. Publish a Make or n8n Workflow**

1. Click **“Publish Other Template.”**

<img alt="PixPin_2025-12-12_17-16-26.png" />

2. Fill in the form with the following details:
   1. **Template name** and **cover image**
   2. Select the **platform** (Make or n8n)
   3. Upload the **required JSON file**
   4. Add a **workflow diagram** or **template URL** for reference
   5. Complete **category**, **tags**, and **description** fields
3. Click **“Submit.”** Review usually takes up to **48 hours.**

<img alt="PixPin_2025-12-12_17-16-47.png" />

💡 **Tip:**  To make your workflow usable directly inside **Make** or **n8n**,  be sure to **link the BrowserAct workflow** used within it under **“Related BrowserAct Templates.”**  Only **BrowserAct workflows that have already been published** can be linked.

<img alt="PixPin_2025-12-12_17-17-06.png" />

***

## ✅ **7. Complete Your Creator Profile**

1. Click the ✏️ icon next to your avatar to open **Profile Settings.**

<img alt="PixPin_2025-12-12_17-17-40.png" />

2. Upload a profile picture, add your social media links, and write a short bio.
3. Click **Submit for Review.**

<img alt="PixPin_2025-12-12_17-18-00.png" />

4. Once approved, your profile will appear on your **public creator page.**

***

## ✅ **8. View Your Creator Page**

After your profile and templates are approved,  BrowserAct will automatically generate a **public creator page** showing:

* Your avatar and bio
* All your published templates
* Direct links for other users to view and use your workflows

<img alt="PixPin_2025-12-12_17-18-21.png" />

***

## ✅ **9. Rewards and Earnings**

* **Welcome Bonus** — Earn **10,000 credits** for your first published template.
* **Weekly Reward Pool** — Join the **\$500 cash reward pool** every week.
* Earn more credits as your templates are used and gain visibility through the community.


# Still Need Help?
Source: https://docs.browseract.com/workflow/help/resources-support/still-need-help



* 🔍 Search docs above
* 💬 Ask in [Discord community](https://discord.com/invite/UpnCKd7GaU)
* 📧 Email [service@browseract.com](mailto:service@browseract.com)


# Support & Community
Source: https://docs.browseract.com/workflow/help/resources-support/support-community



### Get Help

**Discord (fastest):**

* 💬 [Join community](https://discord.com/invite/UpnCKd7GaU)
* Best for: Quick questions, urgent issues
* Response: Real-time (usually)

**Email:**

* 📧 [service@browseract.com](mailto:service@browseract.com)
* Response: Within 48 hours
* Best for: Complex issues with screenshots

**Include this info:**

* Screenshots or error codes
* Methods you've already tried
* Workflow ID or Task ID

***

### Product Roadmap

**View plans:**

* 📍 [Official roadmap](https://www.browseract.com/blog/browseract-roadmap)

**Request features:**

1. Join [Discord](https://discord.gg/UpnCKd7GaU)
2. Go to **#feature-requests** channel
3. Share your idea!


# Tutorials & Resources
Source: https://docs.browseract.com/workflow/help/resources-support/tutorials-resources



**Getting Started:**

* [Build Your First Workflow (5 min)](https://docs.browseract.com/workflow/learn/quick-start/build-your-first-data-scraper-workflow-in-5-minutes)

**Data Extraction:**

* [Extract Data Node Guide](https://docs.browseract.com/workflow/learn/node-types/extract-data-node)
* [List to Detail Pages](https://docs.browseract.com/workflow/learn/case-studies/case-1-deep-extraction-from-list-page-to-detail-page)

**Integrations:**

* [Make.com Setup](https://docs.browseract.com/workflow/learn/quick-start/use-browseract-in-n8n-make-zapier)
* [n8n Setup](https://docs.browseract.com/workflow/learn/quick-start/use-browseract-in-n8n-make-zapier)
* [Google Sheets Sync](https://docs.browseract.com/workflow/help/integrations-apis/how-to-import-data-to-google-sheets)

**Advanced:**

* [API Documentation](https://www.browseract.com/reception/integrations/api-workflow)
* [Conditional Logic](https://docs.browseract.com/workflow/learn/node-types/condition-node)
* [Webhook Configuration](https://www.browseract.com/reception/integrations/api-workflow)

**Case Studies:**

* [Amazon Product Scraper](https://docs.browseract.com/workflow/learn/case-studies/case-1-deep-extraction-from-list-page-to-detail-page)
* [Himalayas Job scraper](https://docs.browseract.com/workflow/learn/case-studies/case-2-automatic-pagination-and-data-collection-from-multi-page-lists)


# Runtime Environment
Source: https://docs.browseract.com/workflow/help/runtime-environment



### Where Does It Run?

**Entirely in the cloud.** No setup is needed.

**Advantages:**

* ✅ No VPS or local server required
* ✅ No need to keep computer on
* ✅ No software installation
* ✅ 24/7 task execution

***

### IP Addresses & Proxies

**Current:** High-quality residential proxy IPs (auto-rotated)

**Custom IPs?** Not yet supported.

🔜 **Coming:** Static browser environment with custom proxies, consistent fingerprints

***

### Website Not Accessible?

**Common causes:**

* Network fluctuations
* Regional blocking
* Server down
* Your IP blocked

**Solutions:**

1. **Wait & retry** (1-2 minutes)
2. **Change proxy region** – Workflow editor → Browser settings
3. **Verify manually** – Test website in your browser
4. **Contact us** – Provide URL, task ID, screenshot

***

### CAPTCHA & Bot Detection

**We support:**

✅ Cloudflare  ✅ reCAPTCHA  ✅ DataDome

**Still blocked?** Contact us with: Website URL, verification screenshot


# Troubleshooting
Source: https://docs.browseract.com/workflow/help/troubleshooting



### Login Credentials Fail in BrowserAct

**Step 1: Test manually**

* Open private/incognito window
* Visit website
* Log in with same credentials
* Do they work?

**Step 2: Check 2FA**

* Is Authenticator app set up?
* Verify secret key (no extra spaces)
* Ensure codes are generating correctly

**Step 3: Re-save credentials**

1. Credential Center → Delete credential
2. Add it again (careful with spaces!)
3. Re-authorize for your workflow

**Step 4: Verify authorization**

* Credential Center → Your credential → Authorized tab
* Status shows "Authorized"?
* Used in correct workflow?

**Still stuck?** Contact us with: Workflow ID, task ID, 2FA screenshot

***

### Workflow Breaks After Website Changes

**Quick fix:**

1. Open failing workflow
2. Re-select element on updated page
3. Test again

**Prevent future breaks:**

* Test workflows weekly

***

### Extracted No Data

**Quick Diagnostics & Solutions:**

**1.Data** **Outside Visible Area**

**Issue:** "Extract from visible area" is enabled, but the target data is below the fold or requires scrolling **Solution:** Add a "Scroll" action before extraction to bring the data into view

***

**2.Data** **on Different Page**

**Issue:** Target data is on a detail page, but you're currently on the listing page **Solution:** Add a "Click" action to navigate to the detail page before extracting

***

**3.Wrong Extraction Node Used**

**Issue:** Used `Extract Data Item` when extracting page-level data **Solution:**

* scraping a full page or capturing all items at once → **Extract Data** Inside Loop List → **Extract Data Item**

***

**4.Data** **Not Fully Loaded**

**Issue:** Page uses dynamic loading; data shows "Loading..." when extraction runs **Solution:** Add a "Wait" action for 2-5 seconds before extraction

***

**Login Required**

**Issue:** Data is hidden or shows "Please log in" message for unauthenticated users **Solution:** Add login steps at the beginning of your workflow

***

### Best Practice: Configure Login Flow

**Recommended approach:**

Use a **Conditional Node:**

```
1. Visit website
2. Conditional: "Is login button visible?"
   ├─ YES → Click login → Use credentials → Log in
   └─ NO → Skip to business logic
3. Continue workflow
```

This handles:

* Optional login sites
* Already-logged-in sessions
* Dynamic login flows


# Basics
Source: https://docs.browseract.com/workflow/help/workflow-and-nodes/basics



### Loop vs Loop List

**Use the right one:**

| **Feature** | **Loop** | **Loop List** |
| :-: | :-: | :-: |
| **Purpose** | Repeat page actions | Iterate list items |
| **What it does** | Navigate pages, click buttons | Extract each item |
| **Scope** | Entire page | Single item |
| **Exits when** | Element appears/disappears or max iterations | All items done |

**Real examples:**

* ✅ **Loop:** Browse 5 pages of search results
* ✅ **Loop List:** Extract 20 products on current page

→ [Loop List case study: ](https://claude.ai/chat/35710794-9eff-407f-b0c6-0eb474494e77#case-looplist) [Amazon scraper](https://docs.browseract.com/workflow/learn/case-studies/case-1-deep-extraction-from-list-page-to-detail-page)

→ [Loop case study: ](https://claude.ai/chat/35710794-9eff-407f-b0c6-0eb474494e77#case-loop)[Himalayas Job scraper](https://docs.browseract.com/workflow/learn/case-studies/case-2-automatic-pagination-and-data-collection-from-multi-page-lists)

***

### Extract Data vs Extract Data Item

**When to use each:**

| **Node Type** | **Usage Location** | **Extraction Scope** |
| :-: | :-: | :-: |
| Extract Data | Anywhere | Entire page / visible area |
| Extract Data Item | Inside Loop List | The currently focused single item |

**Simple rule:**

```
scraping a full page or capturing all items at once → Extract Data
Inside Loop List → Extract Data Item
```

***

### Extract List to Detail Pages

**How to build this workflow:**

1. **Visit Page** – Go to list page
2. **Loop List** – Iterate through items
3. **Extract Data Item** – Get basic info from each item
4. **Click Element Item** – Click to open detail page
5. **Extract Data** – Get detailed info from detail page
6. **Output Data** – Save results

→ [Complete case study](https://docs.browseract.com/workflow/learn/case-studies/case-1-deep-extraction-from-list-page-to-detail-page)

***

### Workflow vs Intelligent Agent

**Choose based on your needs:**

**Decision:**

* **Use Workflow** when you know exact steps
* **Use Agent** when you want AI to figure it out


# Debug & Monitoring
Source: https://docs.browseract.com/workflow/help/workflow-and-nodes/data-extraction



### View Execution Logs

**Access logs:**

1. **Dashboard** → **Activity Log**
2. Click any task to see:
   1. Screenshots of each step
   2. Extracted data preview
   3. Error messages (if any)
      No newline at end of file


# Data Extraction
Source: https://docs.browseract.com/workflow/help/workflow-and-nodes/data-extraction-help



### **What can you extract?**

✅ Text (headings, paragraphs, lists)

✅ Media (image URLs, links)

✅ Structured data (tables, lists)

✅ Element attributes (buttons, forms)

📅 **Coming soon:** Network requests, video downloads, CSS styles

**💡 Pro tip:** For hidden content, scroll first or click "Load More" buttons.

***

### Login-Protected Websites

✅ **Yes!** We support:

* Username/password login
* CAPTCHA (95% auto-detected)
* 2FA via Authenticator apps (Google, Authy, Microsoft)
* Dynamic content loading

📅 **Coming soon:** Manual CAPTCHA, email/SMS 2FA

**⚠️ Social media warning:**

* Use test accounts only (not production accounts)
* Start with small batches
* Monitor for account restrictions
* Avoid aggressive large-scale scraping

🔜 Better security coming: Static IPs, consistent fingerprints

***

### Export Formats

**Supported output formats:**

| **Format** | **Best For** |
| :-: | :-: |
| **JSON** | API integration, Make/n8n |
| **CSV** | Excel, Google Sheets |
| **XML** | Enterprise systems |
| **Markdown** | Docs, CMS |

💡 **Tip:** Use JSON + Make for real-time Google Sheets sync

***

### How Much Data Can You Extract?

**Short answer:** Unlimited—billed by steps taken.

**Understanding costs:**

* 1 step= 5 credits
* Standard actions: Click, Type, Navigate, Extract, Scroll, etc.

**Real examples (simple website):**

* 10 products ≈ 5-10 steps ≈ **25-50 credits**
* Start with small test runs (verify accuracy)
* Then run in bulk (confirm stability)
* ⚠️ Recommend no more than 10,000 records per run

***

### Concurrent Executions

**How many tasks can run at once?**

* **Free users:** 1 concurrent task
* **Paid users:** Up to 20 concurrent tasks


# Debug & Monitoring
Source: https://docs.browseract.com/workflow/help/workflow-and-nodes/debug-and-monitoring



### View Execution Logs

**Access logs:**

1. **Dashboard** → **Activity Log**
2. Click any task to see:
   1. Screenshots of each step
   2. Extracted data preview
   3. Error messages (if any)


# Files & Downloads
Source: https://docs.browseract.com/workflow/help/workflow-and-nodes/files-and-downloads



The **Download** feature allows BrowserAct workflows to automatically download files from web pages during execution.

It works by triggering download actions through interaction nodes, enabling automated file collection without manual steps.

## What Is Download

Files can be downloaded automatically during workflow execution whenever the workflow interacts with page elements that trigger a download.

Downloads are supported in common interaction steps such as:

* Click Element
* Click Element Item
* Visit Page
* Go Back Tab
* Human Interaction

As long as a page contains a visible and clickable download button or link, the workflow can capture and download the file as part of the run.

## What You Can Do

Use Download to automate file collection from websites, such as:

* Image downloads
* Music and video downloads
* PDF and document downloads
* Dataset and resource downloads
* Bulk content retrieval from listing pages

## Supported Files

BrowserAct supports downloading any file format available on the page.

Examples include:

* Images
* Audio files
* Documents
* Archives
* Other downloadable resources

## Limits

To ensure stable workflow execution, the following limits apply:

**File size**

* Maximum size per file: 50 MB

**Download quantity**

* Maximum downloads per workflow run: 100 files

**Availability**

* Download tasks remain available for up to 30 minutes after workflow execution

**Retention**

* Downloaded files are stored for 7 days
* Files expire automatically after the retention period

## Supported Scenarios

Download works when:

* A page contains a visible download button
* Clicking triggers a direct file download

Currently not supported:

* Hover-triggered download buttons
* Hidden download actions without clickable elements

## Example Use Cases

### Automated Pexels Image Download

1. Visit Page [https://www.pexels.com/](https://www.pexels.com/)
2. Click Element  Click any image on the page
3. Click Element  Click the download button

<img alt="Image (13)" />

4. Retrieve downloaded files  Open Browser Download and download the file

<img alt="Image (14)" />

### Automated Pixabay Music Download

1. Visit Page [https://pixabay.com/music/](https://pixabay.com/music/)
2. Loop List Music list at the bottom of the page
3. Condition  Does the page display pop-up windows?
4. Click Element  Close pop-up
5. Click Element Item  Click the download button
6. Wait  Wait 5 seconds

<img alt="Image (15)" />

7. Retrieve downloaded files  Open Browser Download → Download All

<img alt="Image (16)" />

## FAQ

### Why didn’t the download start?

Possible reasons:

* The download button is not directly clickable
* The button requires hover interaction
* A pop-up or login is blocking the download
* The file exceeds the size limit

Try:

* Using Click Element Item
* Adding a Wait step
* Checking workflow logs

### Why can’t I find my downloaded file?

* Files are stored in **Browser Download**
* Download tasks remain available for 30 minutes after execution
* Files expire in 7 days

### Can I download files that require login?

Yes.

If the workflow includes login steps and the session remains active, downloads will work normally.

### Does BrowserAct support PDF / video / zip downloads?

Yes. Any file format that can be downloaded directly from a webpage is supported.

### **Why should I add a Wait step after triggering a download?**

If multiple download actions are triggered too quickly, the previous request may not finish before a new one starts.  When this happens, the system may prioritize the latest request, which can result in only the most recent file being saved.

Adding a Wait step after each download action gives the system enough time to complete the current download request and improves overall download reliability.

# Integration with Workflows

Download works as part of workflow execution and integrates with:

### Workflow automation

* Trigger downloads via interaction nodes
* Run batch downloads via loops

### Data pipelines

* Combine downloads with scraping workflows
* Automate file collection + data extraction

### Storage & processing

* Download files first, then process them via workflows
* Integrate with downstream automation steps

Download functionality enables workflows to retrieve files directly from websites through interactive steps. It eliminates the need for manual file collection and downloading.


# Files & Downloads
Source: https://docs.browseract.com/workflow/help/workflow-and-nodes/files-downloads



The **Download** feature allows BrowserAct workflows to automatically download files from web pages during execution.

It works by triggering download actions through interaction nodes, enabling automated file collection without manual steps.

## What Is Download

Files can be downloaded automatically during workflow execution whenever the workflow interacts with page elements that trigger a download.

Downloads are supported in common interaction steps such as:

* Click Element
* Click Element Item
* Visit Page
* Go Back Tab
* Human Interaction

As long as a page contains a visible and clickable download button or link, the workflow can capture and download the file as part of the run.

## What You Can Do

Use Download to automate file collection from websites, such as:

* Image downloads
* Music and video downloads
* PDF and document downloads
* Dataset and resource downloads
* Bulk content retrieval from listing pages

## Supported Files

BrowserAct supports downloading any file format available on the page.

Examples include:

* Images
* Audio files
* Documents
* Archives
* Other downloadable resources

## Limits

To ensure stable workflow execution, the following limits apply:

**File size**

* Maximum size per file: 50 MB

**Download quantity**

* Maximum downloads per workflow run: 100 files

**Availability**

* Download tasks remain available for up to 30 minutes after workflow execution

**Retention**

* Downloaded files are stored for 7 days
* Files expire automatically after the retention period

## Supported Scenarios

Download works when:

* A page contains a visible download button
* Clicking triggers a direct file download

Currently not supported:

* Hover-triggered download buttons
* Hidden download actions without clickable elements

## Example Use Cases

### Automated Pexels Image Download

1. Visit Page [https://www.pexels.com/](https://www.pexels.com/)
2. Click Element  Click any image on the page
3. Click Element  Click the download button

<img alt="Image (13)" />

4. Retrieve downloaded files  Open Browser Download and download the file

<img alt="Image (14)" />

### Automated Pixabay Music Download

1. Visit Page [https://pixabay.com/music/](https://pixabay.com/music/)
2. Loop List Music list at the bottom of the page
3. Condition  Does the page display pop-up windows?
4. Click Element  Close pop-up
5. Click Element Item  Click the download button
6. Wait  Wait 5 seconds

<img alt="Image (15)" />

7. Retrieve downloaded files  Open Browser Download → Download All

<img alt="Image (17)" />

## Best Practices

* Use visible download buttons
* **Add wait steps after triggering downloads**
* Use looplist for batch downloading
* Avoid hover-only download interactions

## FAQ

### Why didn’t the download start?

Possible reasons:

* The download button is not directly clickable
* The button requires hover interaction
* A pop-up or login is blocking the download
* The file exceeds the size limit

Try:

* Using Click Element Item
* Adding a Wait step
* Checking workflow logs

### Why can’t I find my downloaded file?

* Files are stored in **Browser Download**
* Download tasks remain available for 30 minutes after execution
* Files expire in 7 days

### Can I download files that require login?

Yes.

If the workflow includes login steps and the session remains active, downloads will work normally.

### Does BrowserAct support PDF / video / zip downloads?

Yes. Any file format that can be downloaded directly from a webpage is supported.

### **Why should I add a Wait step after triggering a download?**

If multiple download actions are triggered too quickly, the previous request may not finish before a new one starts.  When this happens, the system may prioritize the latest request, which can result in only the most recent file being saved.

Adding a Wait step after each download action gives the system enough time to complete the current download request and improves overall download reliability.

# Integration with Workflows

Download works as part of workflow execution and integrates with:

### Workflow automation

* Trigger downloads via interaction nodes
* Run batch downloads via loops

### Data pipelines

* Combine downloads with scraping workflows
* Automate file collection + data extraction

### Storage & processing

* Download files first, then process them via workflows
* Integrate with downstream automation steps

Download functionality enables workflows to retrieve files directly from websites through interactive steps. It eliminates the need for manual file collection and downloading.


# Case 1: Deep Scraping from List to Detail Pages
Source: https://docs.browseract.com/workflow/learn/case-studies/case-1-deep-extraction-from-list-page-to-detail-page

Master the core automation pattern of traversing search results and extracting deep data from detail pages, using Amazon as a practical example.

## 1. Case Overview

This case study demonstrates the most core pattern in web automation: **"List Traversal + Detail Page Extraction."**

The core logic involves the AI first identifying a search result list, then sequentially entering each product's detail page (secondary page) to collect more complete and deep data fields, and finally exporting them into a structured table.

This case uses **Amazon** as an example to demonstrate a complete "Search-List-Detail" scraping workflow. Please note that while Amazon is the subject, the underlying **automation logic** is universally applicable to any website with a "List Page + Detail Page" structure (e.g., recruitment, real estate, and news sites).

<img alt="Gemini_Generated_Image_rl8gq6rl8gq6rl8g.png" />

## 2. Detailed Steps

### 1. [Visit Page](/workflow/learn/node-types/visit-node) (Open Website)

* **Objective:** Simulates opening a browser and entering a specific website address.
* **Configuration:**
  * **URL:** Enter the Amazon homepage address: `https://www.amazon.com/`.
  * **Tab:** Select **Current Tab Access** (operate within the current tab).

<img alt="image.png" />

### 2. [Click Element](/workflow/learn/node-types/click-element-node) (Handling Random Pop-ups)

* **Objective:** Handles potential interruptions like "Continue Shopping" prompts or ads. If a pop-up appears, the AI closes it; otherwise, it ignores the step.
* **Configuration:**
  * **Where to click:** Select the close button of the interfering pop-up.
  * **Key Setting:** Under **In Abnormal Situation**, select **Ignore this node and continue execution**.
  * **Why this setting:** This instructs the AI to dismiss the pop-up if present, but proceed seamlessly if the pop-up is absent (intelligent fault tolerance).

<img alt="PixPin_2025-12-03_20-29-55.png" />

### 3. [Input Text](/workflow/learn/node-types/input-text-node) (Search Keywords)

* **Objective:** Locates the search box, types the keyword, and initiates the search.
* **Configuration:**
  * **Input Location:** Select the search bar at the top of the page.
  * **Input Text:** Enter `laptop`.
  * **Key Setting:** Check **Press "Enter" after typing**. This allows the AI to automatically submit the search after typing, eliminating the need for a separate "Click Search Button" step.

<img alt="PixPin_2025-12-03_20-31-58.png" />

### 4. [Loop List](/workflow/learn/node-types/loop-list-node) (Identify List)

* **Objective:** Identifies the collection of products to be processed, preparing the AI to iterate through them one by one.
* **Configuration:**
  * **List Range:** Select the area containing all the products.
  * **Limit:** For testing purposes, enter `10` to limit the process to the first 10 items and optimize execution time.

<img alt="PixPin_2025-12-03_20-32-54.png" />

### 5. [Click Element Item](/workflow/learn/node-types/click-element-item-node) (Enter Detail Page)

* **Objective:** Clicks on the title of the current product within the list to navigate to its detailed view.
* **Configuration:**
  * **Note:** This step must be placed **inside** the **Loop List** node.
  * **Where to click:** Click on the product title text.

<img alt="PixPin_2025-12-03_20-33-53.png" />

### 6. [Extract Data](/workflow/learn/node-types/extract-data-node) (Copy Data)

* **Objective:** Captures specific information (such as Brand, Model, Memory) from the detail page.
* **Configuration:**
  * **What to extract:** Define the target fields (e.g., Brand, Model) and select the corresponding content on the page.

<img alt="PixPin_2025-12-03_20-34-39.png" />

### 7. Finish (Save File)

* **Objective:** Compiles the extracted data and saves it into a structured file format.
* **Configuration:**
  * **Format:** Select **CSV**, the universal standard for spreadsheet data.

<img alt="PixPin_2025-12-03_20-35-12.png" />

## 3. Human Operation vs. AI Nodes

To help you apply this method to other websites, let's compare **Human Logic** with **AI Logic**. You will observe that the AI's process mirrors human behavior.

| **Your Action (Human Operation)** | **Corresponding AI Node** | **Function Description** |
| :- | :- | :- |
| **Open browser**, enter URL. | **Visit Page** | The start of the task. |
| **See an ad pop-up**, close it immediately. | **Click Element** (Set to Ignore) | "Intelligent Fault Tolerance": ignore if absent, close if present. |
| **Type in search box**, press Enter. | **Input Text** (Check "Enter") | Triggers the search to find your target. |
| **Look at the rows** of products on the screen. | **Loop List** | Tells the AI: "These identical-looking items are the list we need to process." |
| **Click the 1st title** with the mouse. | **Click Element Item** | Navigates from the list page to the detail page (secondary page). |
| **Copy and paste** detailed params to Excel. | **Extract Data** | The core action of scraping/grabbing data. |
| **Save** the Excel file. | **Finish** | Exports data and completes the task. |

### Summary

Regardless of the website you encounter in the future, as long as you want to implement a **"Search List -> Click to View Details"** workflow, simply replicate the block assembly logic outlined above.


# Case 2: Auto-Pagination for Multi-Page Lists
Source: https://docs.browseract.com/workflow/learn/case-studies/case-2-automatic-pagination-and-data-collection-from-multi-page-lists

Learn how to automate data extraction across multiple pages using the Loop node, including auto-pagination and conditional stopping.

## 1. Case Overview

This case demonstrates another high-frequency pattern in web automation: [******Using the Loop node to repeatedly turn pages and collect data in a multi-page list until a specific condition is met.******](/workflow/learn/node-types/loop-node)

The core logic is as follows:

1. The AI opens a job listing page.
2. Inside a [**Loop**](/workflow/learn/node-types/loop-node), it repeatedly executes: **Collect current page data → Turn to next page → Wait for new page to load**.
3. The Loop automatically decides when to stop based on your settings (e.g., "until 50 job postings are collected").
4. Finally, it exports all job information as structured data.

This case uses the "Customer Service Job List" from a remote work website as an example to demonstrate a complete "Multi-Page List Auto-Pagination + Batch Collection" workflow.

**Note:** This logic is equally applicable to any list page with a pagination bar (e.g., recruitment, e-commerce products, articles, event lists).

<img alt="Gemini_Generated_Image_quo95yquo95yquo9.png" />

## 2. Detailed Steps

### 1. [Visit Page](/workflow/learn/node-types/visit-node) (Open Job List)

* **Objective:** Open the target job list page directly, rather than navigating from the homepage.
* **Configuration:**
  * **URL:** Enter the list page address, e.g., `https://himalayas.app/jobs/customer-service`.
  * **Tab:** Select **Current Tab Access**.
  * **In Abnormal Situation:** Keep **Stop Task** (if this step fails, there is no point in continuing).

>

<img alt="PixPin_2025-12-04_11-19-51.png" />

### 2. [Loop](/workflow/learn/node-types/loop-node) (Cycle Control: Paginating until 50 items are collected)

* **Objective:** Repeat the entire set of actions "Collect Current Page → Next Page → Wait" until the condition you set is met: **Collect 50 job items** or reach the maximum number of cycles.
* **Configuration:**
  * **Check Timing:** Select **Before each cycle, check the stop condition**.
  * **Stop Condition:** Enter `Until 50 items are collected` in the input box. This means "stop when the number of collected items reaches 50."
  * **Max Duration number of cycles:** Enter `100` to limit the loop to a maximum of 100 rounds, preventing infinite loops in extreme cases.
  * **In Abnormal Situation:** Temporarily keep **Stop Task**. If a critical error occurs within the Loop, the task can be terminated immediately.

> **Explanation:** The Loop is the core of this workflow. You are telling the AI: "Run at most 100 laps, but you can stop once you have 50 job items."

<img alt="PixPin_2025-12-04_11-18-57.png" />

### 3. [Extract Data](/workflow/learn/node-types/extract-data-node) (Collect Current Page Info)

* **Note:** This node is a **child node** of the Loop, meaning it will execute once in every cycle.
* **Objective:** On the current page, copy information from all visible job cards (e.g., Job Title, Publish Date) and append it to the existing dataset.
* **Configuration:**
  * **Capture the page area range:** Select **Full Page** (convenient for scenarios where the whole page is a list).
  * **Data Field:** List the field names you want to collect, such as:
    * **Job Title**
    * **Publish Date**
  * **Filtering Criteria:** Leave unchecked (do not filter the list yet).
  * **In Abnormal Situation:** Keep **Stop Task**, implying that if data cannot be collected, the task should stop.

> **Note:** Once this step is complete, the "number of collected items" will increase, giving meaning to the Loop condition `Until 50 items are collected`.

<img alt="PixPin_2025-12-04_11-20-45.png" />

### 4. [Pagination](/workflow/learn/node-types/pagination-node) (Turn to Next Page)

* **Note:** Also a child node of the Loop. After collecting one page, flip to the next.
* **Objective:** Find the pagination bar at the bottom of the page and click "Next" to enter the next page of the job list.
* **Configuration:**
  * **Next Page / Previous Page:** Select **Next Page**. This tells the Pagination node to specifically handle the "Next" button click.
  * **Element Selection:** Mark the "Next" button or the corresponding pagination element on the page.
  * **In Abnormal Situation:** Keep **Stop Task**.

<img alt="PixPin_2025-12-04_11-20-51.png" />

### 5. [Wait](/workflow/learn/node-types/wait-node) (Wait for New Page Load)

* **Objective:** After clicking "Next Page," do not immediately resume collecting. Give the page some time to complete loading.
* **Configuration:**
  * **Wait:** Set to `3` seconds, for example.
  * **Tip:** For environments with unstable networks, consider increasing the wait time. In advanced usage, this can be replaced with "Wait for element to appear" for a smarter approach.
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Reasoning:** Since the webpage may not load all information immediately, you need to tell the AI: "Wait a moment after turning the page, let the new job cards appear, and then extract."

<img alt="PixPin_2025-12-04_11-20-55.png" />

### 6. Finish: Output Data (Export All Collected Jobs)

* **Objective:** When the Loop determines that "50 job items have been collected" or the maximum cycles are reached, unify and export all data collected from previous pages.
* **Configuration:**
  * **Output Format:** The current selection is **JSON**, which is suitable for subsequent program processing or secondary development. If you prefer a table, you can choose CSV.
  * **Output as a file:** Check this if you need to generate a local downloadable file. If unchecked, the structured result returns in the log.
  * **In Abnormal Situation:** Keep **Stop Task**.

<img alt="PixPin_2025-12-04_11-21-00.png" />

## 3. Human Operation vs. AI Nodes

To better understand the workflow, compare how a human operates versus how the AI nodes are structured. You will see they follow the exact same logic.

| **Your Action (Human Operation)** | **Corresponding AI Node** | **Function Description** |
| :- | :- | :- |
| **Open browser**, enter the job list URL. | [**Visit Page**](/workflow/learn/node-types/visit-node) | Starts the task, landing immediately on Page 1 of the list. |
| **Set a goal:** Collect at least 50 jobs, or keep turning pages if not enough. | [**Loop**](/workflow/learn/node-types/loop-node) | Sets the cycle rules and stop conditions (e.g., "Until 50 items are collected" or "Max 100 pages"). |
| **Browse** the job cards on the current page, noting down the title and date. | [**Extract Data**](/workflow/learn/node-types/extract-data-node) | Batch scrapes fields (Job Title, Publish Date, etc.) from the current page and adds them to the dataset. |
| **Scroll down** to the bottom and click the "Next" button. | [**Pagination**](/workflow/learn/node-types/pagination-node) (Next Page) | Automatically clicks the "Next Page" element in the pagination bar to navigate. |
| **Wait** for the new page of jobs to load. | [**Wait**](/workflow/learn/node-types/wait-node) | Pauses to allow the page to stabilize and content to appear before the next collection round. |
| **Repeat:** "Record jobs → Click Next → Wait" until total jobs ≥ 50 or the last page is reached. | [**Loop**](/workflow/learn/node-types/loop-node) (Execution) | Executes the sequence *Extract Data → Pagination → Wait* repeatedly, checking the stop condition before/after each round. |
| **Organize** all recorded job info into a structured list. | **Finish: Output Data** | Exports all data collected throughout the entire loop process into a single JSON/CSV file. |

### Summary

Whenever you encounter a **"Multi-Page List"** and your thought process is: "I want to turn pages one by one and copy the first N items," simply build the blocks following this Case 2 structure:

1. **Outer Layer:** Use [**Loop**](/workflow/learn/node-types/loop-node) to control "Pagination + Conditional Stop".
2. **Inside Loop:** Place [**Extract Data**](/workflow/learn/node-types/extract-data-node)\*\* → [****Pagination****](/workflow/learn/node-types/pagination-node) → \*\*[**Wait**](/workflow/learn/node-types/wait-node).
3. **Final Step:** Use **Finish** to export the results at once.


# Case 3: Auto-expanding Long List and Scraping
Source: https://docs.browseract.com/workflow/learn/case-studies/case-3-automatic-expansion-and-collection-on-long-load-more-lists

Automate data extraction from long lists that require clicking Load More or scrolling, using Crutchfield as an example.

## 1. Case Overview

This case demonstrates a very frequent pattern in web automation: **Automatically loading more content in a long list and collecting data until a condition is met.**

Typical characteristics of this list type include:

* The page retains a single "Load More" button that appears continuously.
* Clicking it appends a batch of new content to the bottom of the same page.
* Alternatively, simply scrolling down triggers the automatic loading of more data, without a traditional pagination bar.

In this case, we focus exclusively on Long Lists:

Using the Crutchfield TV product list as an example, we will demonstrate how to use Loop List + Auto-click Load More to continuously expand the list, traverse each product, and collect data on the same page.

**Note:** This pattern applies to all multi-page lists that rely on "Load More / Infinite Scroll." As long as the page URL doesn't change and content is just appended downwards, you can use this logic.

<img alt="Gemini_Generated_Image_ah9lmuah9lmuah9l.png" />

## 2. Detailed Steps

### 1. [Visit Page](/workflow/learn/node-types/visit-node) (Open TV Product List)

* **Objective:** Open the Crutchfield TV list page directly, avoiding the need to navigate step-by-step from the homepage.
* **Configuration:**
  * **URL:** `https://www.crutchfield.com/S-YkA30Gowvuu/shopsearch/TV.html?fa=1&pg=1` (You can replace this with any other category or search result page; the logic is identical).
  * **Tab:** Select **Current Tab Access**.
  * **In Abnormal Situation:** Keep **Stop Task** (if the list page cannot be accessed, there is no point in continuing).

<img alt="PixPin_2025-12-04_11-30-25.png" />

### 2. [Loop List](/workflow/learn/node-types/loop-list-node) (Traverse List + Auto-click Load More)

* **Core Logic:** This node is the heart of this pattern.
* **Objective:** Tell the AI: "This entire area is a product list. Please process items one by one. If a 'Load More' button appears at the bottom, click it automatically to load more products until the limit is reached or there is no more content."
* **Configuration:**
  * **List Region:** Select the entire list area containing the TV product cards on the page. Description example: `The main TV product list in the middle of the page.`
  * **Max items to focus:** Enter `10` (for example) to traverse at most the first 10 products.
  * **Load More / Auto-load:** Check the option **Auto-click "Load More" button when present to load more items**.
    * **Meaning:** When the Loop List detects a "Load More" button at the bottom, it will automatically click it, wait for new products to load, and then continue traversing.
  * **In Abnormal Situation:** Keep **Stop Task**.
  * **Note:** You do **not** need a separate "Pagination" node. The **Loop List** node handles both the traversal and the "Load More" clicking action automatically.

<img alt="PixPin_2025-12-04_11-30-31.png" />

### 3. [Extract Data Item](/workflow/learn/node-types/extract-data-item-node) (Scrape Fields for Each Product)

* **Important:** This node must be placed **inside** the **Loop List** node so that it executes automatically for every product in the list.
* **Objective:** For the currently focused TV product card, extract specific fields such as Name, Price, and Rating.
* **Configuration:**
  * **Data Field Examples:** (Adjust based on the actual page)
    * **Product Name:** The title of the product.
    * **Price:** The current selling price.
    * **Rating:** User rating (if available on the page).
  * **Filtering Criteria:** Leave unchecked (unless you have specific filtering needs).
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Effect:** Every time the Loop List moves to a new product card, it triggers this **Extract Data Item** node to append that product's info to the result set.

<img alt="PixPin_2025-12-04_11-30-37.png" />

### 4. Finish: Output Data (Export All Products)

* **Objective:** Once the Loop List finishes traversal (reaching the "Max items" count or when no new products appear), compile all collected records into structured data.
* **Configuration:**
  * **Output Format:** Select **CSV** (for Excel/Spreadsheets) or **JSON** (for API/Developers).
  * **Output as a file:** Check this if you want a direct download. Uncheck if you only need the data in the logs/API response.
  * **In Abnormal Situation:** Keep **Stop Task**.

<img alt="PixPin_2025-12-04_11-30-42.png" />

## 3. Human Operation vs. AI Nodes

To better understand the workflow, compare how a human operates versus how the AI nodes are structured.

| **Your Action (Human Operation)** | **Corresponding AI Node** | **Function Description** |
| :- | :- | :- |
| **Open** Crutchfield's TV list page. | **Visit Page** | Opens the target list directly, skipping homepage navigation. |
| **Browse** the list from top to bottom. | **Loop List** | Locks onto the product list area and traverses items sequentially. |
| **Look** at the current product and copy Name, Price, Rating. | **Extract Data Item** (Child of Loop List) | Extracts fields from the currently focused card and adds them to the results. |
| **Scroll** to the bottom, see "Load More," and click it. | **Loop List** (Built-in Auto-click) | Automatically detects and clicks "Load More" to append items. |
| **Continue** scrolling and copying new items as they appear. | **Loop List** (Driver) | Drives the "Expand + Traverse" process within the same page. |
| **Stop** when enough items are collected, and organize the list. | **Finish: Output Data** | Exports all collected results (CSV/JSON). |

## 4. Summary

Whenever you encounter a **"Load More / Infinite Scroll"** multi-page list with the characteristic: **"The page doesn't change, but clicking 'Load More' or scrolling down appends more content,"** you can directly apply this Case 3 pattern:

1. Use **Loop List** to lock the list region.
2. Check the **Auto-click Load More** option.
3. Place an **Extract Data Item** node inside the Loop List.
4. Use **Finish: Output Data** to export the results.

This ensures a stable, automatic scraping process for all "single-page expansion" lists.


# Case 4: Precise Scraping with Conditional Filtering
Source: https://docs.browseract.com/workflow/learn/case-studies/case-4-precise-collection-from-lists-with-condition-based-filtering

Learn how to filter and scrape only specific items from a list based on criteria (e.g., discounts) using conditional logic, with eBay as an example.

## 1. Case Overview

This case demonstrates a very common e-commerce scenario: The list contains many items, but we only want to scrape those that **"meet specific criteria"** and skip the rest.

In this example, we open an eBay search result page for laptops and check the first 10 items one by one:

* **Check:** Does this item have a "Bulk Savings" discount text? (e.g., *Save up to 10% when you buy more*).
* **If Yes:** Record the **Product Name + Price**.
* **If No:** Skip this item immediately and look at the next one.

**Key Logic:**

1. [**Loop List**](/workflow/learn/node-types/loop-list-node)**:** Responsbile for focusing on each product card sequentially.
2. [**Condition**](/workflow/learn/node-types/condition-node)**:** Performs a judgment on each product.
   * **True:** Execute subsequent scraping nodes.
   * **False:** Do nothing, automatically skipping to the next product.

Although this case uses eBay, this **"List Traversal + Condition Filtering"** logic is universal for any website where only a subset of items in a list match your needs, such as:

* Scraping only discounted items.
* Scraping only items with a "Prime" badge.
* Scraping only content tagged "New" or "HOT".

<img alt="Gemini_Generated_Image_4qya5i4qya5i4qya.png" />

## 2. Detailed Steps

### 1. [Visit Page](/workflow/learn/node-types/visit-node) (Open Search Results)

* **Objective:** Simulates opening a browser and entering the eBay search URL.
* **Configuration:**
  * **URL:** `https://www.ebay.com/sch/i.html?_nkw=laptop`
  * **Tab:** Select **Current Tab Access**.
  * **In Abnormal Situation:** Keep **Stop Task**.

<img alt="PixPin_2025-12-04_11-32-51.png" />

### 2. [Loop List](/workflow/learn/node-types/loop-list-node) (Traverse Product List)

* **Objective:** Tell the AI: "This entire area is the product list. Please process items one by one."
* **Configuration:**
  * **List Region:** Select the main search result area in the middle of the interface. Description example: `In the middle of the interface, the search results list`.
  * **Max items to focus:** Enter `10` (focus on the first 10 items for quick testing).
  * **Auto-click "Load More":** Leave unchecked (eBay uses pagination, not infinite scroll).
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Tip:** As long as the Loop List region is selected accurately, the subsequent logic can be reused regardless of how complex the list is.

<img alt="PixPin_2025-12-04_11-32-59.png" />

### 3. [Condition](/workflow/learn/node-types/condition-node) (Check for Bulk Discount)

* **Important:** This node must be placed **inside** the **Loop List** node. This ensures the condition applies to the "currently focused product card."
* **Objective:** Check the description area of the current product: Is there a bulk purchase discount prompt like *"Save up to 10% when you buy more"*?
* **Configuration:**
  * **Condition Description:** `Are there discounts for bulk purchases? For example, "Save up to 10% when you buy more."`
  * **In Abnormal Situation:** Keep **Stop Task**.
* **Logic Explanation:**
  * **True Branch:** The product has the discount text → Considered a "matching item," proceed to scrape.
  * **False Branch:** The product lacks this text → Do nothing, automatically return to Loop List to check the next item.

<img alt="PixPin_2025-12-04_11-35-49.png" />

### 4. [Extract Data Item](/workflow/learn/node-types/extract-data-item-node) (True Branch: Scrape Matching Items)

* **Context:** This node is placed on the **True** branch of the Condition node.
* **Objective:** Copy the core information of this "discounted product."
* **Configuration:**
  * **Data Field:** Define the fields you need, for example:
    * **Product Name**
    * **Product Price**
  * **Selection:** Select the title and price elements on the current product card.
  * **Filtering Criteria:** Leave unchecked.
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Note:** The **Extract Data Item** only applies to the "current item." The Loop List handles moving the focus to the next item automatically.

<img alt="PixPin_2025-12-04_11-36-01.png" />

### 5. Finish (Output Results)

* **Objective:** After the Loop List finishes processing the first 10 items, compile all "matching items" into structured data.
* **Configuration:**
  * **Output Format:** Select **CSV** or **JSON** based on your needs.
  * **Output as a file:** Check this if you want a direct download link.
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Result:** The final export will be a list containing only the "Discounted Items" with their names and prices.

<img alt="PixPin_2025-12-04_11-36-09.png" />

## 3. Human Operation vs. AI Nodes

To better understand the workflow, compare how a human operates versus how the AI nodes are structured.

| **Your Action (Human Operation)** | **Corresponding AI Node** | **Function Description** |
| :- | :- | :- |
| **Open browser**, enter eBay laptop search URL. | **Visit Page** | Opens the target search result page to start the task. |
| **Look** at the long list of search results, ready to check them one by one. | **Loop List** | Tells the AI: "This entire area is the product list," and iterates through items. |
| **Glance** at a product card: Does it say "Save up to 10%..."? | **Condition** (Inside Loop List) | Judges the current item: Has Discount → True; No Discount → False. |
| **If Yes (True):** Write down the name and price in your notebook. | **Extract Data Item** (True Branch) | Executes only when Condition is True, extracting Product Name and Price. |
| **If No (False):** Ignore it and look at the next item. | **False Branch** (Empty) | No action is taken. The Loop List automatically moves focus to the next item. |
| **Final Step:** Save the list of "Discounted Items" you collected. | **Finish** | Compiles all recorded data and exports it as CSV/JSON. |

### Summary

The essence of this case is **"Filter first, then Scrape"** rather than scraping everything.

1. **Loop List** handles "Looking one by one."
2. **Condition** handles "Do I want this?"
3. **Extract Data Item** handles "If I want it, write it down."

Whenever you have a requirement like **"Only scrape items that are On Sale / Prime / Specific Tag,"** you can simply build this **Loop List + Condition + Extract Data Item** combination.


# Case 5: Precise Scraping with Multi-Dimensional Filtering
Source: https://docs.browseract.com/workflow/learn/case-studies/case-5-precise-scraping-with-multi-dimensional-filtering

Learn how to combine search keywords, category filters, and AI-based content filtering for precise data extraction, using Amazon as an example.

## 1. Case Overview

Often, we don't want to "scrape all products." Instead, we want to:

Narrow down the scope first, and then only keep the small subset of results that "truly meet the criteria."

A typical operation usually involves **three layers of filtering**:

1. **Search Box Filtering:** First, input keywords (e.g., "laptop") in the search box to narrow down from the entire site to a specific category.
2. **Category Filtering (Sidebar/Conditions):** Check filter conditions on the left or top of the page, such as "Hard Drive Size 1TB" or "CPU Brand Intel".
3. **Content-Level Filtering (AI Filtering):** Even if the website has already filtered the results, we may still only want items that satisfy a specific text condition. For example: *Only keep laptops that mention "Energy efficiency."*

This case uses the **Amazon laptop search page** as an example to demonstrate a complete **"Three-Layer Filtering + Scraping"** workflow:

1. Search for "Laptop" in the search box.
2. Check "Hard Drive Size" and "CPU Brand" in the left sidebar filters (controlled by parameters).
3. Traverse the search result list and only collect laptop information that contains energy-efficiency-related content.
4. Export the filtered results as a CSV table.

Applicability:

This logic works for any common website (E-commerce, Recruitment, News, SaaS Dashboards) that features:

* A Search Box
* A Category/Filter Panel
* A List + Item Descriptions

<img alt="Gemini_Generated_Image_ekglncekglncekgl.png" />

## 2. Detailed Steps (Step-by-Step Guide)

### 1. Start (Optional: Parameterize Filter Conditions)

* **Recommendation:** This step is optional but highly recommended to make the workflow flexible and reusable.
* **Objective:** Define "filter condition parameters" in the Start node so subsequent nodes can reference them using `/parameter_name`.
* **Example Parameters:**
  * `hard_drive_size`: e.g., "1 TB"
  * `cpu_manufacturer`: e.g., "Intel"
* **Benefit:** When reusing the workflow, users only need to change the parameters instead of editing individual nodes.

<img alt="PixPin_2025-12-04_11-40-13.png" />

### 2. [Visit Page](/workflow/learn/node-types/visit-node) (Open Amazon Homepage)

* **Objective:** Open the Amazon homepage and prepare to search.
* **Configuration:**
  * **URL:** `https://www.amazon.com/`
  * **Tab:** Select **Current Tab Access**.
  * **In Abnormal Situation:** Keep **Stop Task**.

<img alt="PixPin_2025-12-04_11-40-19.png" />

### 3. [Input Text](/workflow/learn/node-types/input-text-node) (Search Box Filter: Keyword = Laptop)

* **Layer 1 Filtering:** Use the site's built-in search box to lock the scope to "Laptops."
* **Objective:** Find the top search box, type "Laptop," and press Enter.
* **Configuration:**
  * **Input Field Position:** Select the **Top Search Box**.
  * **Text to Input:** Enter `Laptop` (or reference a parameter like `/keyword`).
  * **Setting:** Check **Press "Enter" after typing**. This triggers the search automatically.
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Result:** The page changes from the "Site Homepage" to the "Laptop Search Result List."

<img alt="PixPin_2025-12-04_11-40-26.png" />

### 4. [Scroll to Element](/workflow/learn/node-types/scroll-to-element-node) (Scroll to Filter Area: HDD Size)

* **Layer 2 Filtering - Step 1:** Bring the left filter panel into view.
* **Objective:** Scroll down the page until the "Hard Drive Size" section appears on the left.
* **Configuration:**
  * **Description:** `Scroll down to see the Hard Drive Size filter on the left`.
  * **Max Scroll Iterations:** e.g., `10 screens`.
  * **In Abnormal Situation:** Keep **Stop Task**.

<img alt="PixPin_2025-12-04_11-40-33.png" />

### 5. [Click Element](/workflow/learn/node-types/click-element-node) (Select HDD Size Filter)

* **Objective:** Under the "Hard Drive Size" category, click the desired capacity option (e.g., 1 TB).
* **Configuration:**
  * **Description:** `Click on the /hard_drive_size option under Hard Drive Size category on the left`.
  * **Action:** Select the corresponding checkbox on the page. (If using the `/hard_drive_size` parameter, the AI will match the option based on the text).
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Result:** The product list is now filtered by the website to show "Laptops + Specified HDD Size."

<img alt="PixPin_2025-12-04_11-40-39.png" />

### 6. [Scroll to Element](/workflow/learn/node-types/scroll-to-element-node) (Scroll to CPU Brand Filter Area)

* **Objective:** Scroll down further until the CPU manufacturer filter section appears.
* **Configuration:**
  * **Description:** `Scroll down to see the CPU manufacturer filter on the left`.
  * **Max Scroll Iterations:** `10 screens`.
  * **In Abnormal Situation:** Keep **Stop Task**.

<img alt="PixPin_2025-12-04_11-40-46.png" />

### 7. [Click Element](/workflow/learn/node-types/click-element-node) (Select CPU Brand Filter)

* **Objective:** Under the CPU Manufacturer category, click the specified brand (e.g., Intel, or from a parameter).
* **Configuration:**
  * **Description:** `Click on the /cpu_manufacturer option under CPU Manufacturer category`.
  * **Action:** Select the corresponding brand checkbox on the page.
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Milestone:** The first two layers of filtering are complete using native website features: Search Keywords + Left Sidebar Filters.

<img alt="PixPin_2025-12-04_11-40-52.png" />

### 8. [Loop List](/workflow/learn/node-types/loop-list-node) (Traverse Filtered Product List)

* **Layer 3 Start:** In the filtered result list, perform "Content-Level Filtering."
* **Objective:** Treat the middle product search results as a list and traverse each item sequentially.
* **Configuration:**
  * **List Region:** Select the product card area in the middle. Description: `Search results list in the middle`.
  * **Auto-click "Load More":** Check if applicable based on page structure (pagination vs. load more).
  * **Max items to focus:** e.g., `10` (adjust as needed).
  * **In Abnormal Situation:** Keep **Stop Task**.

<img alt="PixPin_2025-12-04_11-40-57.png" />

### 9. [Extract Data Item](/workflow/learn/node-types/extract-data-item-node) + Filtering Criteria (Content Filtering: Energy Efficiency Only)

* **Layer 3 Filtering:** Do not rely on the website anymore; perform content filtering during the **Scraping Phase**.
* **Objective:** For the currently focused product card:
  1. Read fields like Product Name and Price.
  2. Only write to the results if the "Product info involves energy efficiency."
* **Configuration:**
  * **Node Type:** **Extract Data Item** (Child of Loop List).
  * **Data Fields:**
    * **Product Name**
    * **Price**
  * **Filtering Criteria:** Check this box.
  * **Description:** `Collect laptops that include Energy efficiency`. (Only collect laptops where the description mentions energy efficiency).
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Effect:** For every item, the AI reads the text. If it matches "Includes Energy efficiency," the Name and Price are saved. If not, it skips the item entirely.

<img alt="PixPin_2025-12-04_11-41-11.png" />

### 10. Finish: Output Data (Export Filtered Results)

* **Objective:** Once traversal is complete, export all products that passed the "Three-Layer Filter."
* **Configuration:**
  * **Output Format:** Select **CSV** (convenient for spreadsheet viewing).
  * **Output as a file:** Select based on need.
  * **In Abnormal Situation:** Keep **Stop Task**.

> **Final Output:** A precise list that has passed Search Box + Category Filter + AI Text Content Filter.

<img alt="PixPin_2025-12-04_11-41-17.png" />

## 3. Human Operation vs. AI Nodes

To better understand the workflow, compare how a human operates versus how the AI nodes are structured.

| **Your Action (Human Operation)** | **Corresponding AI Node** | **Function Description** |
| :- | :- | :- |
| **Think:** "I want a 1TB HDD, Intel CPU laptop, specifically mentioning energy efficiency." | **Start** (Input Parameters) | Abstract conditions into parameters (`hard_drive_size`, `cpu_manufacturer`) for easy reuse. |
| **Open** Amazon homepage. | [**Visit Page**](/workflow/learn/node-types/visit-node) | Starts the entire operation. |
| **Type** "Laptop" in top search box and press Enter. | [**Input Text**](/workflow/learn/node-types/input-text-node) | **Layer 1 Filter:** Narrow scope from "All Site" to "Laptops." |
| **Scroll down** to find the HDD filter on the left. | [\*\*Scroll to Element \*\*](/workflow/learn/node-types/scroll-to-element-node)(HDD Size) | Brings the filter section into view for reliable clicking. |
| **Check** "1 TB" in the HDD section. | [**Click Element**](/workflow/learn/node-types/click-element-node) (HDD Option) | **Layer 2 Filter (Part 1):** Use website filter to limit storage capacity. |
| **Scroll down** to find the CPU brand filter. | [\*\*Scroll to Element \*\*](/workflow/learn/node-types/scroll-to-element-node)(CPU Brand) | Brings the CPU filter section into view. |
| **Check** "Intel" in the CPU section. | [**Click Element**](/workflow/learn/node-types/click-element-node) (CPU Option) | **Layer 2 Filter (Part 2):** Limit CPU brand. |
| **Look** at the filtered results, ready to check one by one. | [**Loop List**](/workflow/learn/node-types/loop-list-node) | Treats the middle product cards as a list and iterates through them. |
| **Check each item:** Read description. If it mentions "Energy efficiency," write down Name/Price. Otherwise, skip. | [**Extract Data Item + Filtering Criteria**](/workflow/learn/node-types/extract-data-item-node) | **Layer 3 Filter:** AI-based content filtering during scraping. Only saves matching items. |
| **Compile** the final list of matching laptops into a CSV. | **Finish: Output Data** | Exports the multi-dimensionally filtered data into a structured file. |

### Summary

Case 5 demonstrates a classic **"Three-Layer Filtering + Scraping"** workflow:

1. **Search Box:** Narrow scope from full site to a category.
2. **Category Filter:** Use native website filters to tighten conditions.
3. **Content Filter:** Use AI during scraping for the final "Only keep results matching specific text criteria" layer.

Whenever you have a requirement like **"Filter by keyword first, then check categories, and finally only keep a specific subset of matching items,"** you can directly build this workflow.


# Integrate BrowserAct with Make
Source: https://docs.browseract.com/workflow/learn/integrations/make

Run your BrowserAct workflows from Make as part of your larger automation

**📚 This is a How-To Guide** – You already have a working BrowserAct workflow, and you want to trigger it from Make. This guide shows you how.

**⏱️ Estimated time:** 15-20 minutes

## 🎯When Should You Use This?

Use this guide if you want to:

* **Trigger a BrowserAct workflow from Make** – Use Make when scheduled runs need to continue into other Make modules.
* **Trigger from external events** – Webhook, form submission, API call, etc.
* **Use data from other platforms** – Google Sheets, Airtable, email, Salesforce, etc.
* **Send results to downstream tools** – Email, Slack, database, CRM, Airtable, Notion, etc.
* **Build end-to-end automations** – Data source → BrowserAct → Results → Action

### ❌ You DON'T Need This If...

You just want to run a workflow manually in BrowserAct. That's already easy – just click "Run"!

You also don't need Make if you only want BrowserAct to run a published Bot on a schedule and email results from inside BrowserAct. Use [BrowserAct schedules](/bot/schedules/schedule-bot-runs) for that.

### ✅ Prerequisites

✓BrowserAct Account + Working Workflow

✓Go to BrowserAct → Workflows → pick one that's Published and tested

#### Your API Key Ready

✓In BrowserAct: Settings → Integrations & API → "Generate API Key" → Copy it

#### Make Account (Cloud)

✓Make is cloud-only – sign up at [make.com](http://make.com) if you haven't already

#### Basic Make Knowledge

Know how to add modules and create basic scenarios in Make

## 🔄How It Works (Visual Overview)

Your Data Source (Sheets, Webhook, Schedule, Airtable) ↓  **Make** (Decides WHEN to run & WHERE data comes from) ↓  **BrowserAct** (Runs your web automation workflow) ↓  **Results** (Structured data back to Make) ↓  Your Destination (Email, Slack, Airtable, Notion, Database, etc.)

<img alt="Pix Pin 2025 12 04 11 16 24" />

## 🚀Integration Steps

### Step 1: Create a New Scenario (or Open Existing)

1. Log into Make
2. Click **"Create a new scenario"** (or open an existing one)
3. Add your trigger module (Scheduler, Webhook, Google Sheets, etc.)

### Step 2: Add BrowserAct Module

1. Click **"Add module"** after your trigger or another module
2. Search for **"BrowserAct"**
3. Click to add the BrowserAct module to your scenario

### Step 3: Connect Your Account

1. In the BrowserAct module, click the **Connection** dropdown
2. Select **"Create a new connection"**
3. Enter your BrowserAct API key
4. Click **Save** to connect

💡 **Make tests the connection automatically.** If you see a green checkmark ✓, you're connected!

### Step 4: Choose Your Workflow

1. Make sure **Action** is set to `Run a workflow`
2. Choose **Search Workflows From**:
   1. **My Workflows** – Your own workflows (most common)
   2. **Template Marketplace** – Pre-built templates (optional)
3. Select your BrowserAct workflow from the dropdown list

### Step 5: Map Input Parameters

After choosing a workflow, Make shows all input parameters it needs (like "City", "URL", "Keyword", etc).

For each parameter:

1. Enter a **fixed value** (if the same every time), OR
2. Click the input field and **map from previous modules**:
   1. From scheduler? Use fixed value or timestamp
   2. From spreadsheet? Map the column
   3. From webhook? Map the received field
   4. From CRM? Map the contact field

Example:

City: map from [GoogleSheets.city](http://GoogleSheets.city)

URL: map from [webhook.website](http://webhook.website)

Keyword: enter fixed value "competitor"

### Step 6: Test the Integration

1. Click **"Run once"** button to test the module
2. Make will execute BrowserAct with your test parameters
3. You'll see the output panel showing your scraped data
4. If you see results, you're ready! If there's an error, check troubleshooting below

### Step 7: Deploy & Activate Scenario

1. Click **"OK"** to accept the test results
2. Click the toggle switch in the top-right to **turn on** your scenario
3. Your Make scenario is now live and will run automatically!

### Step 8: Add Downstream Modules (Optional)

Now that your BrowserAct module runs, add more modules after it:

* **Google Sheets** – Add rows with results
* **Slack** – Send messages with data
* **Email** – Email the results
* **Airtable** – Create records
* **Notion** – Create database entries
* **Salesforce** – Create leads/opportunities
* **Filter** – Conditional logic for branching

Chain these modules to create your complete automation!

## 📋Real-World Scenarios

### Scenario 1: Daily Lead Generation Report

**What happens:** Every morning at 9am, scrape leads and email the sales team

Scheduler (trigger every day at 9am)

↓

BrowserAct (scrape leads from directory)

↓

Airtable (store leads)

↓

Email (send daily report)

↓

✅ Sales team gets leads automatically

**Setup:** Scheduler → BrowserAct → Airtable → Email

### Scenario 2: Form Submission → Data Enrichment → Salesforce

**What happens:** Website form submitted → Get company data → Add to CRM

Webhook (form submission)

↓

BrowserAct (lookup company info)

↓

Salesforce (create contact)

↓

✅ Leads automatically enriched in CRM

**Setup:** Webhook → BrowserAct → Salesforce

### Scenario 3: Monitor Price Changes & Alert

**What happens:** Every hour, check prices, post to Slack if prices drop

Scheduler (every hour)

↓

BrowserAct (get current prices)

↓

Filter (price dropped?)

↓

Slack (send alert)

↓

✅ Team notified of price changes

**Setup:** Scheduler → BrowserAct → Filter → Slack

## 🆘Troubleshooting

#### ❌ "Authentication Failed" or "Invalid Credentials"

Make can't connect to BrowserAct

**Fix:** (1) Double-check your API key is correct (copy from BrowserAct Settings) (2) Make sure you didn't accidentally add spaces or extra characters (3) If the key is old, generate a new one in BrowserAct (4) Delete and recreate the connection in Make

#### ❌ "Workflow Not Found"

Make can't find your BrowserAct workflow

**Fix:** (1) Make sure workflow is Published in BrowserAct (2) Refresh the workflow dropdown (click the circular refresh icon) (3) Double-check you're in "My Workflows" not "Templates" (4) Try re-connecting (delete connection, create new one)

#### ❌ "Missing Required Parameter"

Input parameters don't match what BrowserAct expects

**Fix:** (1) Check that all required parameters have values (2) Verify parameter names exactly match (case-sensitive!) (3) Make sure mapped data is actually coming from previous modules (4) Click "Run once" to see what data is being sent

#### ❌ Scenario Runs but BrowserAct Returns No Data

Workflow executes but results are empty/null

**Fix:** (1) Test the workflow directly in BrowserAct (does it work there?) (2) Check parameters are correct (try with same test data as BrowserAct) (3) The website might have changed (layouts, elements moved) (4) Check if website blocks automation (you might need proxy/delays)

#### ❌ "Execution Timeout" Error

Workflow takes too long to complete

**Fix:** (1) Test if website loads slowly (manually check in browser) (2) In BrowserAct, add Wait nodes to give page time to load (3) Some sites block bots (try different approach or contact support) (4) Increase timeout in BrowserAct workflow settings if available

### 🚀 What's Next?

You now have basic Make integration. Consider these next steps:

**1️⃣ Set Up Automation Schedule** Configure your Scheduler module to run regularly (daily, hourly, weekly, etc.)

**2️⃣ Add More Downstream Modules** Send results to Slack, Email, Airtable, Notion, Salesforce, and more

**3️⃣ Use Filter/Router for Logic** Add conditional logic to decide what to do based on the results

**4️⃣ Batch Process with Repeater** Use Repeater module to loop through multiple items and process each with BrowserAct

**5️⃣ Build Complex Workflows** Combine BrowserAct with Make's 1000+ apps to create sophisticated business automations

**Resources:** • [BrowserAct API Reference](https://www.claudeusercontent.com/reference/api) • [Make Documentation](https://www.make.com/en/help/docs) • [More How-To Guides](https://www.claudeusercontent.com/learn/how-to-guides) • [BrowserAct Support](https://www.claudeusercontent.com/help)


# Integrate BrowserAct with MCP
Source: https://docs.browseract.com/workflow/learn/integrations/mcp

Run your BrowserAct workflows from MCP Clients as part of your larger AI automation

<iframe title="YouTube video player" />

## What is BrowserAct MCP Server?

BrowserAct **MCP Server** is a standardized service that lets **MCP Clients** interact with the BrowserAct platform through the [**Model Context Protocol (MCP)**](https://modelcontextprotocol.io/docs/getting-started/intro). With it, MCP Clients can:

* **Discover and execute** browser automation workflows as **MCP Tools**
* **Read outputs** (results, files) and access related data storage
* **Trigger real-world actions** via natural language (e.g., send messages, create tasks, update records)

### Key Features

* **Multi-Scenario Support:** Enables MCP Clients to run targeted tasks or complex searches across different applications
* **Natural Language Interaction:** Describe what you need—no complex code or commands
* **Unlimited Tool Exposure:** One MCP Server can expose unlimited **MCP Tools**
* **Multi-Client Compatibility:** Works with Claude, ChatGPT, OpenAI Agent Builder, and other MCP-compatible clients

### Use Cases

BrowserAct **MCP Tools** are a good fit when you want an **MCP Client** to:

* Automate browser operations (web scraping, form filling, navigation)
* Run repetitive tasks across multiple platforms
* Call workflows directly from a chat interface
* Turn complex workflows into simple, natural-language requests

***

## Supported MCP Clients

BrowserAct MCP Server supports MCP-compatible clients, including:

| Category | Examples |
| :- | :- |
| **LLM Interfaces** | ChatGPT, Claude |
| **Development Platforms** | OpenAI Agent Builder, OpenAI API, Anthropic API |
| **CLI Tools** | Claude Code, Gemini CLI |
| **Code Editors** | Cursor, Windsurf, Wrap, VS Code |

*Note: Any tool that supports the MCP standard is also compatible.*

***

## How to Create MCP Tools and Connect to MCP Clients

### Prerequisites

Make sure you have:

1. A **BrowserAct account** (sign up for free)
2. A workflow ready to convert into an **MCP Tool**
3. An **MCP Client** (e.g., Claude Desktop or ChatGPT)

***

## Part 1: Convert a Workflow into an MCP Tool

### 1) Enable MCP Configuration

* Open your target workflow in BrowserAct
* Click **MCP Configure** (top-right)
* Toggle **MCP-Ready** to **ON**

> **Important:** Turning on **MCP-Ready** does *not* activate the tool immediately.\
> After you finish configuration, you **must publish the workflow** for the MCP Tool to take effect. MCP Clients will only run the **latest published version**.

<img alt="Pix Pin 2025 12 18 11 41 12" />

***

### 2) Configure Basic Information

#### Tool Call Name

* **Requirements:** 2–32 characters; must start with a letter; only letters, numbers, and underscores
* **Must be unique** within your account
* **Example:** `Reddit_Scraper_Tool`

#### Description

* Explains **what the tool does** and **how the MCP Client should use it**
* **Example:** “Reddit scraper that extracts posts and comments from any subreddit. Captures titles, text, timestamps, and user details.”

#### Tool Output Method

* Choose **Text** or **File** depending on output size and how you plan to consume results

<img alt="Pix Pin 2025 12 18 11 41 50" />

***

### 3) Configure Input Parameters

Input parameters control what values are passed into the workflow when the MCP Tool is called.

**Key behavior for MCP Tools**

* Input values are stored **server-side** and are **not visible** to MCP Clients
* Once published, input parameter settings **cannot be modified** (you must update and republish)

Two supported modes:

#### Mode A: AI-Inferred

* The MCP Client fills the value at runtime based on the parameter description
* **Requirement:** Write descriptions that are explicit enough for the MCP Client to infer correctly
* **Example:** `DataLimit` → “Enter the number of data items to extract per run.”

<img alt="Pix Pin 2025 12 18 11 42 32" />

#### Mode B: Fixed Value

* Uses a constant value for every execution
* **Example:** Set `DataLimit` to `20`

<img alt="Pix Pin 2025 12 18 11 42 55" />

***

### 4) Publish (Required)

Click **Publish** (top-right) to publish the workflow.

> **Publishing is required** for MCP Tool configuration changes to become active.\
> If you only configure but don’t publish, MCP Clients will still run the **previous published version** (or won’t see the tool at all, depending on exposure).

<img alt="Pix Pin 2025 12 18 11 43 19" />

***

## Part 2: Create an MCP Server and Expose MCP Tools

### 1) Navigate to MCP Server Settings

You can access this in either way:

* From the publish success popup: click **Expose on MCP Server**
* From the Dashboard: click **MCP Servers**

<img alt="Pix Pin 2025 12 18 11 44 08" />

***

### 2) Add an MCP Server

1. Click **+ Add**
2. **Server Name:** e.g., `Server-20251217-01`
3. **Description (optional):** e.g., `Social Media Automation`
4. Click **Confirm**

<img alt="Pix Pin 2025 12 18 11 44 35" />

***

### 3) Expose MCP Tools

1. In the MCP Server list, select your target **MCP Server** and click **Management**
2. Go to **Exposed Tools** → **Not Exposed**
3. Select the **MCP Tools** you want to expose and click **Expose**
4. Click **Confirm**

<img alt="Pix Pin 2025 12 18 11 45 18" />

<img alt="Pix Pin 2025 12 18 11 45 43" />

***

## Part 3: Connect an MCP Server to MCP Clients

Each MCP Server has a unique **MCP Server URL** and **API Key**. You need the **matching pair** to connect an MCP Client.

### 1) Retrieve MCP Server URL and API Key

1. In the MCP Server list, select the target server and click **Management**
2. Open **Connect to Clients**
3. Copy the **MCP Server URL**
4. Click **Create New API Key**, then copy the key

<img alt="Pix Pin 2025 12 18 11 46 09" />

***

### 2) Configure the MCP Client

1. Select your **MCP Client** (e.g., Claude, ChatGPT)
2. Click the client icon to view setup instructions
3. Follow the instructions to update the client configuration

*Note: If your MCP Client is not listed, follow its documentation for adding a generic MCP Server.*

***

## Troubleshooting

### MCP Client shows an authentication error

* Confirm the **API Key** is correct
* Verify the key in **Management → Connect to Clients**
* Ensure the key hasn’t been deleted/revoked

### MCP Client can’t find MCP Tools

* Confirm the **MCP Server URL** is correct
* Ensure the **MCP Server** is online
* Confirm at least one MCP Tool is **exposed** on the MCP Server
* Confirm the workflow has **MCP-Ready** enabled
* Confirm the workflow has been **published** (unpublished changes do not apply)

### MCP Client can’t execute operations

* Check BrowserAct account credits
* Confirm the tool is correctly configured and exposed on the MCP Server
* Improve tool descriptions if the MCP Client fails to trigger it reliably
* Check whether usage limits have been reached

### Execution issues (no response / long delays)

* Execution time depends on workflow complexity
* Check **Execution Logs** in MCP Server management for status and error details

***

## FAQ

**1. Can all workflows be converted into MCP Tools?**\
Yes—except workflows that require manual credential input for each run.

**2. How many MCP Servers can a user create?**

* **Free users:** 1 MCP Server
* **Paid users:** Unlimited MCP Servers

**3. How many MCP Tools can be exposed per MCP Server?**\
No limit. One MCP Server can expose unlimited MCP Tools.

**4. Can input parameters be modified after configuration?**\
No. After publishing, parameters are fixed. To change them, update the workflow and publish a new version.

**5. Does an offline MCP Server affect MCP Client connections?**\
Yes. MCP Clients cannot connect or execute tools while the MCP Server is offline (exposure settings remain saved).

**6. Do API Keys expire?**\
Not by default. Keys can be manually revoked or regenerated in MCP Server management.

**7. Where can I view execution results?**\
In the MCP Server list, open **Management** for the server to view logs, execution time, and error details.

**8. Do MCP Tools sync automatically when a workflow is updated?**\
Yes—**after you publish**. MCP Tools always run the **latest published version**. If you only edit configuration without publishing, MCP Clients will continue using the previous published version.


# Integrate BrowserAct with n8n
Source: https://docs.browseract.com/workflow/learn/integrations/n8n

Run your BrowserAct workflows from n8n as part of your larger automation

**📚 This is a How-To Guide** – You already have a working BrowserAct workflow, and you want to trigger it from n8n. This guide shows you how.

**⏱️ Estimated time:** 15-20 minutes

## 🎯When Should You Use This?

Use this guide if you want to:

* **Trigger a BrowserAct workflow from n8n** – Use n8n when scheduled runs need to continue into other n8n nodes.
* **Trigger from external events** – Webhook, database update, webhook, etc.
* **Use data from other platforms** – Google Sheets, Airtable, email, Slack, etc.
* **Send results to downstream tools** – Email, Slack, database, CRM, etc.
* **Build end-to-end automations** – Data source → BrowserAct → Results → Action

### ❌ You DON'T Need This If...

You just want to run a workflow manually in BrowserAct. That's already easy – just click "Run"!

You also don't need n8n if you only want BrowserAct to run a published Bot on a schedule and email results from inside BrowserAct. Use [BrowserAct schedules](/bot/schedules/schedule-bot-runs) for that.

### ✅ Prerequisites

✓BrowserAct Account + Working Workflow

✓Go to BrowserAct → Workflows → pick one that's Published and tested

#### Your API Key Ready

✓In BrowserAct: Settings → Integrations & API → "Generate API Key" → Copy it

#### n8n Account

✓Either n8n Cloud (easiest) or self-hosted n8n instance (v1.0+)

#### Basic n8n Knowledge

Know how to add nodes and create basic workflows in n8n

## 🔄How It Works (Visual Overview)

Your Data Source (Sheets, Webhook, Schedule, Database) ↓  **n8n** (Decides WHEN to run & WHERE data comes from) ↓  **BrowserAct** (Runs your web automation workflow) ↓  **Results** (Structured data back to n8n) ↓  Your Destination (Email, Slack, Database, Sheet, etc.)

<img alt="Download" />

## 🚀Integration Steps

### Step 1: Add BrowserAct Node to n8n

1. Open your n8n workflow (or create a new one)
2. Click the `+` button to add a node
3. Search for **"BrowserAct"**
4. Click to add the BrowserAct node to your workflow

### Step 2: Connect Your API Key

1. In the BrowserAct node, find the **Credentials** section
2. Click **"Create New Credential"**
3. Paste your BrowserAct API key
4. Click **Save** and select it from the dropdown

💡 **Test the connection:** Click the "Test" button next to your credential. You should see "Connection successful"

### Step 3: Choose Your Workflow

1. In the BrowserAct node, set **Resource** to `Workflow`
2. Set **Operation** to `Run a workflow`
3. Choose search source:
   1. **My Workflows** – Your own workflows (most common)
   2. **Template Marketplace** – Pre-built templates (optional)
4. Select your workflow from the dropdown list

### Step 4: Map Your Input Parameters

After you pick a workflow, n8n automatically shows you all input parameters that workflow needs (like "City", "URL", "Keyword", etc).

Now map data from previous nodes:

1. For each parameter field, click the input area
2. Choose **Mapping** mode (click the icon with 3 dots)
3. Select the field from your previous node:
   1. From Google Sheets? Pick the column name
   2. From webhook? Pick the field name
   3. From database? Pick the data field

Example mapping:

BrowserAct param "City" ← Sheets column "city"

BrowserAct param "Keyword" ← Webhook field "search\_term"

BrowserAct param "URL" ← CRM field "website"

### Step 5: Test the Integration

1. Click the **"Test"** button (or press `Cmd/Ctrl + Enter`)
2. n8n will execute your BrowserAct workflow with test data
3. You'll see your scraped data in the output panel on the right
4. If you see results, you're ready! If there's an error, check troubleshooting below

### Step 6: Save Your Workflow

1. Click **"Save"** to save your workflow
2. Your n8n workflow is now ready to use!

### Step 7: Add Downstream Actions (Optional)

Now that your BrowserAct node runs, you can add more nodes after it:

* **Google Sheets** – Write results to a spreadsheet
* **Email** – Send results via email
* **Slack** – Post to Slack channel
* **Database** – Store in PostgreSQL, MongoDB, etc.
* **IF/Router** – Branch logic based on results
* **HTTP Request** – Send to any webhook

These nodes will receive the data from BrowserAct and do something with it!

## 📋Real-World Scenarios

### Scenario 1: Daily Competitor Price Check → Email

**What happens:** Every morning at 8am, check competitor prices and email the team

Scheduler (trigger every day at 8am)

↓

BrowserAct (get competitor prices)

↓

Google Sheets (update data)

↓

Email (send daily report)

↓

✅ Team gets daily report automatically

**Setup:** Scheduler → BrowserAct → Sheets → Email

### Scenario 2: Webhook Trigger → Enrich Data → Store

**What happens:** Website form submitted → Get company data → Add to database

Webhook (form submission)

↓

BrowserAct (look up company info)

↓

Database (store enriched data)

↓

✅ Lead data automatically enriched

**Setup:** Webhook → BrowserAct → Database

### Scenario 3: Batch Process Spreadsheet Rows

**What happens:** Process 100 products from Google Sheets, run BrowserAct for each one

Google Sheets (product list)

↓

Loop (for each row)

↓

BrowserAct (extract data for each product)

↓

Update Sheets (add results back)

↓

✅ All products enriched in one go

**Setup:** Sheets → Loop → BrowserAct → Update Sheets

## 🆘Troubleshooting

#### ❌ "API Key Invalid" or "Connection Failed"

n8n can't authenticate with BrowserAct

**Fix:** (1) Double-check your API key is correct (copy from BrowserAct Settings) (2) Make sure key is not expired or regenerated (3) Try creating a new API key if needed (4) Click "Test Connection" button in n8n to verify

#### ❌ "Workflow Not Found"

n8n can't find your BrowserAct workflow

**Fix:** (1) Make sure workflow is Published in BrowserAct (2) Refresh the workflow dropdown (sometimes cache needs refresh) (3) Check you're looking in "My Workflows" not "Templates" (4) Try re-authorizing your connection (delete and recreate credential)

#### ❌ "Parameter Mismatch" or "Field Not Found"

Input parameters don't match what BrowserAct expects

**Fix:** (1) Check parameter names are exact match (case-sensitive!) (2) Verify data types (string vs number vs boolean) (3) Make sure previous node outputs the field you're mapping (4) Use "Test" button to see the actual data being sent

#### ❌ Workflow Runs but Returns Empty/Null Results

BrowserAct runs but doesn't find data

**Fix:** (1) Test the workflow directly in BrowserAct first (does it work there?) (2) Check that parameters are being passed correctly (3) Verify the website hasn't changed (layouts change, elements move) (4) Check if you're hitting rate limits (too many runs too fast)

#### ❌ Timeout Error (Workflow takes too long)

Workflow execution exceeds time limit

**Fix:** (1) Check if website is slow (test workflow manually in BrowserAct) (2) Add wait/delay nodes in BrowserAct if page loads slowly (3) Some websites block automated access (try proxy, add delays) (4) Contact support if legitimate workflow times out

### 🚀 What's Next?

You now have basic n8n integration. Consider these next steps:

**1️⃣ Automate Regularly** Set up a Scheduler node so your workflow runs automatically (daily, hourly) without you doing anything

**2️⃣ Expand Downstream Actions** Send results to more places (email, Slack, multiple sheets, database, CRM, etc.)

**3️⃣ Add Conditional Logic** Use IF/Router nodes to decide what to do based on the results

**4️⃣ Batch Process Multiple Items** Loop through 100s of items from a spreadsheet and process each one with BrowserAct

**5️⃣ Build Complete Workflows** Combine with n8n's 400+ apps to create complex business automations

**Resources:** • [BrowserAct API Reference](https://www.claudeusercontent.com/reference/api) • [n8n Documentation](https://docs.n8n.io/) • [More How-To Guides](https://www.claudeusercontent.com/learn/how-to-guides) • [BrowserAct Support](https://www.claudeusercontent.com/help)


# Introduction
Source: https://docs.browseract.com/workflow/learn/introduction



## Welcome to BrowserAct

BrowserAct is an **AI-powered** web automation platform designed to transform your browser into a scalable digital workforce.

It enables you to convert repetitive manual web operations—such as data scraping, market monitoring, or form automation—into reliable, automated processes without the need for complex coding.

<Columns>
  <Card title="Quick Start Guide" icon="rocket" href="/workflow/learn/quick-start/build-your-first-data-scraper-workflow-in-5-minutes">
    Follow our step-by-step tutorial to build and run your first workflow in under five minutes.
  </Card>

  <Card title="Integrate with Make & n8n" icon="workflow" href="/workflow/learn/quick-start/use-browseract-in-n8n-make-zapier">
    Connect BrowserAct to Make and n8n to orchestrate automation across your existing tools.
  </Card>

  <Card title="Case Studies" icon="Sparkles" href="/workflow/learn/case-studies/case-1-deep-extraction-from-list-page-to-detail-page">
    See how teams use BrowserAct in real-world scenarios — from lead generation and monitoring to internal tools and custom AI workflows.
  </Card>

  <Card title="Help Center" icon="book-open" href="/workflow/help/workflow-and-nodes/basics">
    Stuck? Explore design patterns (like pagination and infinite scrolling), troubleshooting tips, FAQs, and in-depth guides in the Help Center.
  </Card>
</Columns>

## Need more help?

<Card title="Talk to us on Discord" icon="message-circle" href="https://discord.com/invite/UpnCKd7GaU">
  If you’re stuck on a problem you can’t resolve, join our Discord and chat directly with the BrowserAct team and other power users.
</Card>


# Click Element Item Node
Source: https://docs.browseract.com/workflow/learn/node-types/click-element-item-node

A specific child node for Loop List that clicks a link or button within the currently focused list item.

Overview

Click Element Item is a specialized child node designed for use inside a Loop List. It is used to click a specific element within the current list item, such as clicking a title to enter a detail page or clicking a "View Details" button.

<img alt="Gemini_Generated_Image_grr7ozgrr7ozgrr7.png" />

**Use Cases**

* Clicking video titles one by one in a video list to enter detail pages for further data collection.
* Clicking every news headline in a news list to scrape the full article content.
* Clicking product images or titles in a product list to get more specifications or reviews.

**Core Capabilities**

* Locates click targets within the currently focused list item using natural language.
* Triggers page navigation or content expansion.
* Supports continuing with [**Extract Data**](/workflow/learn/node-types/extract-data-node) or other operations after clicking.

**Configuration Steps**

1. Add a [**Click Element Item**](/workflow/learn/node-types/click-element-item-node) node inside a [**Loop List**](/workflow/learn/node-types/loop-list-node).
2. Describe the element to click in **Element Description**, for example:
   * "Click the title link of the current job item"
   * "Click the thumbnail of the current video item"
   * "Click the View Details button in the current product item"
3. After clicking, you can attach [**Extract Data**](/workflow/learn/node-types/extract-data-node) or other nodes within the same loop to complete scraping on the detail page.

<img alt="PixPin_2025-12-04_14-13-52.png" />

**Recommendations**

* Click Element Item can only be used within a Loop List; it cannot be used independently.
* Each node clicks only once. If multiple elements need clicking, chain multiple Click Element Item nodes within the Loop List.
* Emphasize "Current Item" in the description to avoid accidentally clicking other areas of the page.
* For scenarios requiring return to the list page after navigation, combine with **Tab Operation** or **Go Back** actions.


# Click Element Node
Source: https://docs.browseract.com/workflow/learn/node-types/click-element-node

Simulates a mouse click on any button, link, or icon identified by a natural language description.

Master BrowserAct's Click Element node to automate precise clicks on any visible element. Use natural language descriptions to identify buttons, links, and interactive elements without writing code. Perfect for form submissions, navigation, context menu interactions, and triggering page events.

<img alt="Gemini_Generated_Image_5dchmi5dchmi5dch.png" />

## What is the Click Element Node?

The Click Element Node executes precise click actions on visible elements within the current viewport based on your natural language description. Simply describe what you want to click (like "blue search button in the upper right corner"), and the system automatically detects and clicks the element. This node simulates human clicking behavior, triggers page navigation or events, and requires no code.

**Click Type Options**

The Click Element node now supports two click types:

| **Click Type** | **Description** | **Default** |
| :- | :- | :- |
| **Left-click** | Standard mouse left-click action. Used for buttons, links, form submissions, and most interactions. | ✅ Default |
| **Right-click** | Mouse right-click action. Used for opening context menus, accessing additional options, or triggering right-click events. | |

## When Should You Use It?

* **Left-click Use Cases**

Use Left-click (default) when you need to:

• Navigate to the next page by clicking buttons (e.g., click a login button to enter the user dashboard)

• Trigger search queries by clicking search buttons in the page header

• Submit forms or interact with popup menus (e.g., click "Submit" to complete data entry)

• Select checkboxes, radio buttons, or dropdown options

• Click links to navigate between pages

* **Right-click Use Cases**

Use Right-click when you need to:

• Trigger right-click events on interactive elements

• Open links in new tabs via context menu

• Access additional options not available through left-click

## How to Set Up a Click Element Node (Step by Step)

### 1.Insert the Node

Click the **+** button in your workflow, then select "**Click Element Node**" from the node library.

### 2.Describe the Target Element

**Description:**\
Describe the element's location and characteristics.

**Example:**

*Search button in the upper right corner of the page*\
*Submit button at the bottom of the form*\
*Blue 'Continue' button on the right side*

### **3. Select Click Type**

Choose the appropriate click type for your action:

• Left-click (Default): For standard click interactions

• Right-click: For context menu access and right-click events

### **4.Handle Errors (Optional)**

In Abnormal situations: Select "Stop Task" from the dropdown to halt the workflow if the element cannot be found or clicked.

**5.Connect with Other Nodes**

Place the Click Element node after Visit Page nodes and before data extraction nodes.

## Key Rules & Best Practices

### **Rules**

| **Rule** | **Description** |
| :- | :- |
| **Visible elements only** | The Click Element node can only interact with elements currently visible in the viewport. It cannot click hidden or dynamically loaded elements that haven't appeared yet. |
| **One click per execution** | Each Click Element node performs only one click action. For multiple clicks, add multiple Click Element nodes. |
| **Natural language required** | Describe the element using clear, natural language or parameter references. |
| **Click type applies to all scenarios** | Both Left-click and Right-click follow the same element detection logic. |

### **Best Practices**

**Element Description Tips:**

• Include element type: "button," "link," "icon," "checkbox," "image," etc.

• Specify location: "upper right corner," "bottom of the form," "top navigation bar"

• Mention distinctive features: color, text label, size

• Use position references: "first," "second," "third," "next to"

• Be specific: "Blue 'Continue' button on the right side" is better than "Continue button"

## Quick Review

1. **What does the Click Element node do?**

Executes precise click actions on visible elements based on natural language descriptions.

2. **Can you click elements that are not visible in the viewport?**

No, only visible elements can be clicked.

3. **How many clicks can one Click Element node perform?**

One click per node.

4. **When should you use Right-click?**

When you need to access context menus, additional options, or trigger right-click events.

5. **What information should you include in element descriptions?**

Element type, location, distinctive features, and position references.

## Next Steps

The Click Element node is essential for interactive automation workflows—start building your first click automation now! With the new Right-click capability, you can now automate even more complex interactions including context menu operations.

# Need help?

• Join our [Discord community](https://discord.com/invite/UpnCKd7GaU) for live support

• Email us at: [support@browseract.com](mailto:support@browseract.com)


# Condition Node
Source: https://docs.browseract.com/workflow/learn/node-types/condition-node

Creates logical branches (True/False) to direct the workflow based on page content or variables.

Overview

The Condition node performs "branch logic" within a workflow. Based on the current page state or outputs from previous nodes, it decides which subsequent path to execute, enabling intelligent workflow branching.

<img alt="Gemini_Generated_Image_pzn4dmpzn4dmpzn4.png" />

**Use Cases**

* Checking if a user is logged in (e.g., does a "Sign out" button exist on the page?).
* Checking if there is a next page (e.g., is the "Next Page" button clickable?).
* Checking stock status (does the page display "Out of Stock" or "Sold Out"?).
* Handling pop-ups or ad overlays (checking if specific pop-up elements appear).

**Core Capabilities**

* Uses natural language to describe conditions.
* Provides default **True / False** branches, which can connect to any nodes.
* Supports multi-dimensional judgment based on visible page content, URL, variables, preceding node outputs, etc.

**Configuration Steps**

1. Add a **Condition** node.
2. Use natural language in the condition description, for example:
   * "Does the current page display the text 'Out of Stock'?"
   * "Does a 'View All Jobs' button exist?"
   * "Does the current URL contain '/checkout'?"
3. Configure the **True** branch: The chain of nodes to execute when the condition is met.
4. Configure the **False** branch: The chain of nodes to execute when the condition is not met.
5. At runtime, the system automatically evaluates the condition and follows the corresponding branch.

<img alt="PixPin_2025-12-04_14-56-17.png" />

**Recommendations**

* Be as specific as possible when describing conditions. Avoid vague phrases like "Check the button."
* Condition nodes support nesting up to 3 levels; be mindful of branch complexity and maintainability.
* If two branches eventually perform the same behavior, both True and False branches can point to the same subsequent node.
* For very complex logic, split into multiple serial Condition nodes to implement multi-step judgment.


# Extract Data Item Node
Source: https://docs.browseract.com/workflow/learn/node-types/extract-data-item-node

A specific child node for Loop List that captures data fields from the currently focused list item.

Overview

Extract Data Item is a specialized child node designed for use inside a [Loop List](/workflow/learn/node-types/loop-list-node). It extracts specified fields from the currently focused single list item and compiles these fields into structured data.

<img alt="Gemini_Generated_Image_nix1gonix1gonix1.png" />

**Use Cases**

* Extracting "Name, Price, Image, Rating" fields for each product in a product list.
* Extracting "Title, Summary, Date, Likes" information in a post list.
* Extracting "Job Title, Company, Location, Salary Range" in a job list.

**Core Capabilities**

* Batch extracts multiple fields from the current list item.
* Supports filling unified placeholder values (e.g., None) for missing fields.
* Supports filtering criteria configuration to keep only data meeting specific conditions (e.g., posted within the last N days).

**Configuration Steps**

1. Add an **Extract Data Item** node inside a [**Loop List**](/workflow/learn/node-types/loop-list-node).
2. Configure **Data Fields** prompts to clearly describe the fields to extract, for example:
   * "Extract from current job item: Job Title, Company Name, Post Date, Salary Range. If missing, fill N/A."
3. (Optional) Configure **Filtering Criteria**, for example:
   * "Only keep jobs posted within the last 3 days."
4. Upon execution, Loop List runs Extract Data Item for each list item and aggregates the data into a table/dataset.

<img alt="PixPin_2025-12-04_14-17-10.png" />

**Recommendations**

* It is best to configure only one Extract Data Item node per Loop List to maintain a clear structure.
* Clearer field descriptions lead to more stable extraction results; state field names and meanings clearly.
* If the page structure is complex, consider splitting into multiple [Loop List](/workflow/learn/node-types/loop-list-node) + Extract Data Item sets to extract by region.


# Extract Data Node
Source: https://docs.browseract.com/workflow/learn/node-types/extract-data-node

Scrapes structured data from the full page or the current visible area (independent of list loops).

Overview

The Extract Data node is used to extract structured data from the entire page or the current visible area. It is a general-purpose page data collection tool. Unlike Extract Data Item, it does not rely on Loop List and can be used independently.

<img alt="Gemini_Generated_Image_y72nxxy72nxxy72n.png" />

**Use Cases**

* Extracting all matching data from a full page at once (e.g., comment lists, article lists, product info).
* Extracting a set of fields from a detail page (e.g., multiple specification fields on a product detail page).
* Accumulating data from multiple pages when combined with [Pagination](/workflow/learn/node-types/pagination-node) inside a [Loop](/workflow/learn/node-types/loop-node).

**Core Capabilities**

* Supports two extraction scopes: **Full Page** or **Visible Area**.
* Uses natural language to describe fields and positions to extract.
* Supports filtering conditions (filter by time, quantity, attributes, etc.).
* Can output formats like JSON, CSV, XML, Markdown (via Output Data node).

**Configuration Steps**

1. Add an **Extract Data** node.
2. Select extraction scope:
   * **Full Page:** Collect data from the entire page.
   * **Visible Area:** Collect data only from the current viewport.
3. Clearly specify content to extract in the field description. For example:
   * "Extract from product detail page: Product Name, Current Price, Original Price, Stock Status, Rating, Review Count, Seller Name, Shipping Info."
4. (Optional) Configure filtering criteria, for example:
   * "Only keep reviews from the last 30 days."
   * "Only extract products with a price greater than 100."
5. For cross-page extraction, place Extract Data inside a [Loop](/workflow/learn/node-types/loop-node) or combine with [Pagination](/workflow/learn/node-types/pagination-node).

<img alt="PixPin_2025-12-04_14-18-10.png" />

**Recommendations**

* For scenarios with complex page structures, consider using multiple Extract Data nodes to process different areas separately.
* Each Extract Data node executes extraction only once. For multi-page extraction, combine with [Loop](/workflow/learn/node-types/loop-node) + [Pagination](/workflow/learn/node-types/pagination-node).
* Consider adding a [**Wait**](/workflow/learn/node-types/wait-node) node before extraction to ensure dynamic content has loaded.
* Field descriptions should be detailed, including field names and meanings, to facilitate subsequent use and maintenance.


# Hover Element
Source: https://docs.browseract.com/workflow/learn/node-types/hover-element-node



Master BrowserAct's Hover Element node to automate precise mouse hover actions on any visible element. Use natural language descriptions to identify navigation menus, buttons, and interactive elements without writing code. Perfect for revealing dropdown menus, tooltips, hover cards, and triggering hover-based events.

## What is the Hover Element Node?

The Hover Element Node executes precise mouse hover (mouseover) actions on visible elements within the current viewport based on your natural language description. Simply describe what you want to hover over (like "Products menu item in the top navigation bar"), and the system automatically detects and hovers over the element. This node simulates human mouse movement behavior, triggers hover events, reveals hidden content, and requires no code.

## When Should You Use It?

Use the Hover Element Node when you need to:

• Reveal dropdown menus: Hover over navigation items to expose sub-menu options before clicking

• Show tooltips: Hover over icons or elements to reveal tooltip information for extraction

• Activate hover cards: Hover over user profiles, product thumbnails, or links to show preview cards

• Access mega menus: Large e-commerce sites often use mega menus that require hover to display

• Reveal action buttons: Some interfaces show edit/delete buttons only when hovering over an item

## How to Set Up a Hover Element Node (Step by Step)

**1.Insert the Node**

Click the + button in your workflow, then select "Hover Element" from the node library.

**2.Describe the Target Element**

In the Element Location Description field, describe the element's location and characteristics.

**✅ Correct Examples:**

• "Products" menu item in the top navigation bar

• User avatar icon in the upper right corner

• First product card in the search results

• "More options" icon next to the file name

• Category dropdown trigger in the sidebar

**❌ Incorrect Examples:**

• Hover over the Products menu (don't include "hover" in the description)

• Move mouse to the avatar icon

• Hover over Products menu, then click on Electronics (one action per node)

**3.Handle Errors (Optional)**

In Abnormal situations: Select "Stop Task" from the dropdown to halt the workflow if the element cannot be found.

**4.Connect with Other Nodes**

Place the Hover Element node after Visit Page nodes. Typically follow it with:

• Click Element node: To click on revealed dropdown options

• Extract Data node: To capture tooltip or hover card content

• Wait node: To allow time for hover effects to complete

## Examples

**Revealing a Dropdown Menu**

\*\*Goal: \*\*Hover over a navigation menu to reveal dropdown options, then click a sub-item.

**Step 1: Add Visit Page node**

• URL: [https://www.amazon.com/](https://www.amazon.com/)

• Access Method: Current Tab Access

• Error Handling: Stop Task

**Step 2: Add Hover Element Node**

• Element Description: "Gift Cards" menu item in the top navigation bar

• Error Handling: Stop Task

**Step 3: Add Click Element Node**

• Element Description: "Shop all gift cards" option in the dropdown menu

• Click Type: Left-click

• Error Handling: Stop Task

## Key Rules & Best Practices

* **Rules:**

| **Rule** | **Description** |
| :- | :- |
| Visible elements only | The Hover Element node can only interact with elements currently visible in the viewport. |
| One hover per execution | Each Hover Element node performs only one hover action. |
| Natural language required | Describe the element using clear, natural language. |
| Hover state is temporary | The hover state persists until the next action. |

**Best Practices - Element Description Tips:**

• Include element type: "menu item," "icon," "button," "card," "row"

• Specify location: "top navigation bar," "sidebar," "first row"

• Mention distinctive features: text label, color, icon type

• Use position references: "first," "second," "next to"

**Workflow Tips:**

| **Scenario** | **Recommended Approach** |
| :- | :- |
| Dropdown menus | Hover Element → Click Element |
| Tooltip extraction | Hover Element → Wait (1s) → Extract Data |
| Mega menus | Hover Element → Wait (0.5s) → Click Element |
| Hidden action buttons | Hover Element → Click Element |

## Quick Review

1. **What does the Hover Element node do?**

Executes precise mouse hover actions on visible elements, triggering hover events and revealing hidden content.

2. **Can you hover over elements not visible in the viewport?**

No, only visible elements can be hovered over.

3. **How many hover actions per node?**

One hover per node.

4. **What typically follows a Hover Element node?**

Click Element, Extract Data, or Wait nodes.

5. **How long does the hover state persist?**

Until the next action in the workflow is executed.

## Next Steps

The Hover Element node is essential for interacting with modern web interfaces that rely on hover-based interactions. Combine it with Click Element and Extract Data nodes to build powerful automation workflows.

## Need help?

• Join our [Discord community](https://discord.com/invite/UpnCKd7GaU)

• Email us at: [support@browseract.com](mailto:support@browseract.com)


# Human Interaction Node
Source: https://docs.browseract.com/workflow/learn/node-types/human-interaction-node

Pauses the workflow and hands browser control to a human, then resumes automation after manual actions are completed.

Overview

The Human Interaction node is used when part of a workflow cannot be fully automated and requires human judgment or manual input. When the workflow reaches this node, browser control is temporarily handed over to a human; after the user completes the required actions and confirms, the workflow resumes automatically.

<img alt="Gemini_Generated_Image_9kiorn9kiorn9kio.png" />

**Use Cases**

* Completing login flows that require username, password, and verification codes (e.g., email/SMS OTP).
* Handling captcha-protected pages that must be solved by a human.
* Manually reviewing content or making a decision before continuing (e.g., approve/reject, choose a category).
* Performing sensitive or high-risk operations that should not be fully automated.

**Core Capabilities**

* Pauses the workflow and temporarily transfers browser control to a human operator.
* Supports multiple notification options: in-app notification and optional email notification.
* Allows execution either inside the BrowserAct interface or via a standalone web interface opened from email.
* Automatically resumes the workflow once the human step is completed and confirmed.
* Supports a configurable time limit for how long the workflow waits for human intervention.

**Configuration Steps**

1. Add a **Human Interaction** node to the workflow.
2. In **Instruction for human**, clearly describe what the human should do on the page. For example:
   * "Please enter your username, password, and verification code to complete the login process."
   * "Please solve the captcha and ensure the page successfully loads the dashboard."
3. Set **Time Limit** to define how long the workflow should wait for human intervention. When the time limit expires, this step ends immediately according to your workflow design.
4. Configure **Notify when this step starts**:
   * **Checked:** Enter a valid email address. An email notification will be sent, and the recipient can open a standalone web interface to perform the task—useful when the operator is away from the main console.
   * **Unchecked:** The human performs all actions directly inside the BrowserAct interface without email notification.
5. When execution reaches the Human Interaction node, the operator follows the instructions, completes the required actions in the browser, and clicks **Resume** to continue the workflow.

<img alt="PixPin_2025-12-05_21-11-08.png" />

**Recommendations**

* Keep instructions short, specific, and action-oriented so the human knows exactly what to do.
* Choose a reasonable time limit based on how long the manual step typically takes.
* Use email notifications when the operator may not be in front of the BrowserAct interface.
* Place Human Interaction nodes only at steps that truly require manual actions to avoid unnecessary interruptions.


# Input Text Node
Source: https://docs.browseract.com/workflow/learn/node-types/input-text-node

Automatically types text or variables into input fields, such as search bars or forms.

Overview

The Input Text node is used to automatically enter text into web input fields, such as search bars, form fields, or message boxes, replacing manual entry.

<img alt="Gemini_Generated_Image_7lk8kz7lk8kz7lk8.png" />

**Use Cases**

* Entering keywords in a search box and triggering a search with [Click Element](/workflow/learn/node-types/click-element-node).
* Automatically filling out registration forms, login information, or contact details.
* Entering messages in comment boxes, chat boxes, or guestbooks.
* Using parameters to batch input different content (e.g., different product names, emails).

**Core Capabilities**

* Locates input fields within the visible area via natural language description.
* Automatically clears existing content and enters the specified text.
* Supports referencing preceding node parameters as dynamic input content.

**Configuration Steps**

1. Add an **Input Text** node.
2. Configure **Input Box Description**, for example:
   * "The search box at the top of the page"
   * "The email address input field in the registration form"
   * "The message input box in the bottom right corner of the page"
3. Configure **Text Content**:
   * Directly enter fixed text (e.g., `customer service`).
   * Enter `/` to reference parameters, such as `{{product_name}}` or `{{user_email}}`.
4. At runtime, the node will automatically:
   * Locate the described input box.
   * Clear original content.
   * Enter the specified text and proceed to the next step.

<img alt="PixPin_2025-12-04_14-14-04.png" />

**Recommendations**

* Each Input Text node is responsible for one input field. Use multiple nodes for multiple fields.
* If the input box is not in the current visible area, use a Scroll node first to navigate to the corresponding area.
* For dynamic input (content changing with loops), prioritize using parameter references (`/`) for easier reuse.
* For scenarios where pages load slowly, consider adding a [**Wait**](/workflow/learn/node-types/wait-node) node before Input Text.


# Loop List Node
Source: https://docs.browseract.com/workflow/learn/node-types/loop-list-node

Iterates through a specific list area on the page to process items (extract data or click) one by one.

**Overview**

The Loop List node is used to iterate through every item in a specific "list area" on a page (e.g., job lists, product lists, post lists) and perform child operations (extract, click, etc.) on each item.

<img alt="Gemini_Generated_Image_gayqrfgayqrfgayq.png" />

**Use Cases**

* Batch extracting data from Reddit posts, product cards, job cards, etc.
* Entering the detail page of each item in a list to collect more detailed information.
* Performing the same operation (click, scroll, scrape) on every element in a list.

**Core Capabilities**

* Locates list regions via natural language description.
* Supports setting a maximum number of loop items (**Max Focused Loop Items**).
* Supports a **Load More** option for lists requiring expansion.
* Supports up to 3 levels of nested Loop Lists for complex multi-level lists.

**Configuration Steps**

1. Add a **Loop List** node.
2. Configure basic settings:
   * **List Region Description:** Describe where the list is located, e.g., "The job list area in the middle of the page."
   * **Load More:**
     * Check: If the list requires clicking "Load More" or uses pagination.
     * Uncheck: If the list auto-loads or only the current page is needed.
   * **Max Focused Loop Items:** Maximum number of items to process (e.g., 10, 20, 50), set according to business needs.
3. Add child nodes inside the Loop List:
   * [**Extract Data Item**](/workflow/learn/node-types/extract-data-item-node)**:** Extract fields from the current list item.
   * [**Click Element Item**](/workflow/learn/node-types/click-element-item-node)**:** Click a button or link within the current list item.

<img alt="PixPin_2025-12-04_14-22-01.png" />

**Recommendations**

* Only one Loop List node is allowed per hierarchy level; maximum 3 levels of nesting.
* Loop List requires at least one child node ([**Extract Data Item**](/workflow/learn/node-types/extract-data-item-node) or [**Click Element Item**](/workflow/learn/node-types/click-element-item-node)).
* Setting **Max Focused Loop Items** too high may result in excessive execution time; match it to actual requirements.
* For infinite scroll lists, combine with [**Scroll**](/workflow/learn/node-types/scroll-page-node) nodes and the "Load More" option.

***

**Related Video**

<iframe title="YouTube video player" />


# Loop Node
Source: https://docs.browseract.com/workflow/learn/node-types/loop-node

Repeats a sequence of actions (like pagination or scrolling) until a specific condition is met.

**Overview**

The Loop node is a general-purpose cycle engine used to repeat a specific process flow until an exit condition is met. Unlike Loop List (which iterates through list items), Loop is better suited for repeating "cross-page or cross-action" tasks, such as turning pages or scrolling + extracting.

<img alt="Gemini_Generated_Image_7jw8xh7jw8xh7jw8.png" />

**Use Cases**

* Repeating "[Pagination](/workflow/learn/node-types/pagination-node) + [Extraction](/workflow/learn/node-types/extract-data-node)" operations across multiple pages until a target data count is reached.
* Looping "[Scroll](/workflow/learn/node-types/scroll-page-node) + [Extraction](/workflow/learn/node-types/extract-data-node)" on infinite scroll pages until "No more data" appears.
* Repeatedly clicking a "Load More" button until specific text appears or a condition is met.

**Core Capabilities**

* Supports natural language descriptions for exit conditions (e.g., "Until 50 items are collected").
* Supports setting a maximum iteration count (default 10, max 999) to prevent infinite loops.
* Supports selecting condition check timing (Before Loop / After Loop).
* Supports choosing "Stop Task" or "Skip Current Loop" on errors.

**Configuration Steps**

1. Add a **Loop** node.
2. Configure the exit condition description, for example:
   * "Until the collected product count reaches item\_limit"
   * "Stop when the text 'No more results' appears at the bottom of the page"
3. Set **Max Iterations** (e.g., 10, 20) as a safety cap.
4. Select check timing:
   * **Before Loop:** Check condition before execution; if met, the loop body is not executed.
   * **After Loop:** Execute the loop at least once, then check if it should continue.
5. Add child nodes inside the Loop (such as Scroll, Extract Data, Pagination, etc.) to form the loop body.

<img alt="PixPin_2025-12-04_14-23-11.png" />

**Recommendations**

* Prioritize clear, determinable exit conditions. Avoid vague descriptions like "Until all data is scraped."
* During development and debugging, set specific Max Iterations low (e.g., 2) to test workflow correctness before scaling up.
* Loop is oriented towards controlling "action-level repetition," whereas item-by-item processing is better handled by [**Loop List**](/workflow/learn/node-types/loop-list-node).

***

**Related Video**

<iframe title="YouTube video player" />


# Output Data Node
Source: https://docs.browseract.com/workflow/learn/node-types/output-data-node

Aggregates all collected data and exports it into formats like CSV, JSON, XML, or Markdown.

Overview

The Output Data node is the "closing node" of a workflow. It is specifically used to aggregate the results from all preceding [Extract Data](/workflow/learn/node-types/extract-data-node) / [Extract Data Item](/workflow/learn/node-types/extract-data-item-node) nodes and export them into a specified data format.

<img alt="Gemini_Generated_Image_dc10ovdc10ovdc10.png" />

**Use Cases**

* Exporting collection results to CSV for Excel / Google Sheets analysis.
* Exporting JSON for consumption by other systems or APIs.
* Exporting Markdown for manual review or reporting.

**Core Capabilities**

* Aggregates all structured data outputs generated during workflow execution.
* Supports multiple export formats: JSON, CSV, XML, Markdown.
* Supports downloading results as a file.

**Configuration Steps**

1. Add an **Output Data** node at the end of the workflow (Note: There can be only one, and it must be the last node).
2. Select the output format:
   * **JSON:** Suitable for integrated systems, APIs, automation platforms.
   * **CSV:** Suitable for spreadsheet analysis.
   * **XML:** Suitable for traditional enterprise systems or standardized data exchange.
   * **Markdown (MD):** Suitable for generating readable reports.
3. If a direct file download is required, check the **Output as file** option.
4. After the workflow completes, the output node will provide a download link or viewable result.

<img alt="PixPin_2025-12-04_14-25-07.png" />

**Recommendations**

* Ensure there is at least one [Extract Data](/workflow/learn/node-types/extract-data-node) / [Extract Data Item](/workflow/learn/node-types/extract-data-item-node) node before Output Data; otherwise, the output will be empty.
* If multiple different export formats are needed, convert formats via external tools; keep one Output Data node within the workflow.
* When connecting to automation platforms (like Make, n8n), prioritize the JSON format.


# Pagination Node
Source: https://docs.browseract.com/workflow/learn/node-types/pagination-node

Handles navigation for multi-page content by automatically clicking 'Next' or 'Previous' buttons.

Overview

The Pagination node is used to automatically turn pages in multi-page content, such as clicking "Next Page" or "Previous Page" buttons. It works with [extraction](/workflow/learn/node-types/extract-data-node) nodes to implement batch collection across multiple pages.

<img alt="Gemini_Generated_Image_tj4an5tj4an5tj4a.png" />

**Use Cases**

* Multi-page search results or product lists on e-commerce sites.
* Multi-page job lists on recruitment sites.
* Paginated archive lists on news sites or forums.

**Core Capabilities**

* Supports **Next Page** or **Previous Page** navigation.
* Can generate multi-page loops when combined with [Extract Data](/workflow/learn/node-types/extract-data-node), [Loop List](/workflow/learn/node-types/loop-list-node), Loop, and [Scroll](/workflow/learn/node-types/scroll-page-node) nodes.
* Option to terminate the task or skip and continue upon pagination failure.

**Configuration Steps**

1. Add a **Pagination** node.
2. Select the direction in **Direction**:
   * **Next Page**
   * **Previous Page**
3. Configure error handling strategy:
   * **Stop Task:** Terminate the workflow if pagination fails (e.g., reached the last page).
   * **Skip and Continue:** Ignore the current pagination error and proceed to subsequent nodes.
4. Usually place Pagination after [**Extract Data**](/workflow/learn/node-types/extract-data-node) to ensure current page data is collected before turning the page.

<img alt="PixPin_2025-12-04_14-26-18.png" />

**Recommendations**

* Each Pagination node executes only one page turn action. For batch pagination, combine with **Loop** / **Loop List**.
* If the pagination button is not in the current visible area, use **Scroll Page** or **Scroll to Element** first to scroll to the pagination area.
* For scenarios with an uncertain number of pages, recommend using **Loop** with "Data count/Button status" as the exit condition.


# Scroll Page Node
Source: https://docs.browseract.com/workflow/learn/node-types/scroll-page-node

Performs basic page-level scrolling actions, such as scrolling down one screen or jumping to the bottom.

Overview

The Scroll Page node performs simple overall scrolling actions on the page, such as scrolling down one screen, scrolling to the top, or scrolling to the bottom, to load more content or reveal hidden areas.

<img alt="Gemini_Generated_Image_cmlz5mcmlz5mcmlz.png" />

**Use Cases**

* Scrolling down on long list pages to load more items.
* Scrolling to the bottom of the page to view the footer or pagination area.
* Specifying a particular area to scroll within pages that have multiple scrollable regions.

**Core Capabilities**

* Supports four basic scrolling methods:
  * Scroll down one screen
  * Scroll up one screen
  * Scroll to top page
  * Scroll to bottom page
* Supports identifying multiple scrollable areas (e.g., main content area, sidebar, etc.).

**Configuration Steps**

1. Add a **Scroll Page** node.
2. Select the scrolling direction:
   * **Scroll down one screen**
   * **Scroll up one screen**
   * **Scroll to top page**
   * **Scroll to bottom page**
3. If the page has multiple scrollable areas:
   * Check **Page has multiple scrollable areas**.
   * Specify the area in the description, such as: "Main content area", "Left sidebar", or "Comment section".
4. At runtime, the node executes one scroll action and proceeds to the next step.

<img alt="PixPin_2025-12-04_14-32-32.png" />

**Recommendations**

* Scroll Page scrolls only once per execution. Combine with a [**Loop**](/workflow/learn/node-types/loop-node) node for continuous scrolling.
* For pages using "Scroll down to load more," you can loop: \*\*Scroll Page → \*\*[**Extract Data**](/workflow/learn/node-types/extract-data-node).
* If the goal is to scroll to a specific area (e.g., comments section), consider using the [**Scroll to Element**](/workflow/learn/node-types/scroll-to-element-node) node instead.


# Scroll to Element Node
Source: https://docs.browseract.com/workflow/learn/node-types/scroll-to-element-node

Continuously scrolls the page until a specific target area or element becomes visible in the viewport.

Overview

The Scroll to Element node automatically scrolls the page until a target area or element appears in the viewport. It is suitable for scenarios where you "know where to go, but don't know how much to scroll."

<img alt="Gemini_Generated_Image_a81dxwa81dxwa81d.png" />

**Use Cases**

* Scrolling to the comment section on YouTube, Instagram, or forums.
* Scrolling to a specific "Job List Area" or "Product Review Area" in the middle of a page.
* Scrolling to specific areas like "Form Bottom" or "Footer Subscription Area" on long pages.

**Core Capabilities**

* Locates target areas based on natural language descriptions.
* Automatically scrolls up to approximately 10 screens until the element appears in the visible area.
* Supports target area selection on pages with multiple scrollable regions.

**Configuration Steps**

1. Add a **Scroll to Element** node.
2. Describe the target element/area in the description field, for example:
   * "Comment section"
   * "The job list area in the middle of the page"
   * "The newsletter subscription form at the bottom"
3. If the page has multiple scrollable areas:
   * Check **Page has multiple scrollable areas**.
   * Describe the specific area to scroll (e.g., "Main content area", "Comment area").
4. Configure the maximum scroll attempts (default is roughly 10 screens).
5. At runtime, the node scrolls screen by screen until the target area is located, then executes subsequent nodes.

<img alt="PixPin_2025-12-04_14-33-56.png" />

**Recommendations**

* Descriptions should target the "Area" rather than an action, for example:
  * ✅ "Scroll to the comment section"
  * ❌ "Scroll down until you see the button"
* If you need to click or extract data after scrolling, place [**Click Element**](/workflow/learn/node-types/click-element-node) / [**Extract Data**](/workflow/learn/node-types/extract-data-node) after this node.
* For complex page structures, verify the relative position of the area in a browser before writing the description.

***


# Tab Operation Node
Source: https://docs.browseract.com/workflow/learn/node-types/tab-operation-node

Manages browser tab history and state, performing actions like Go Back or Close Tab.

Overview

The Tab Operation node manages browser tabs within an automation process, such as closing the current tab or navigating back to the previous page. This helps keep the browsing context clean and controllable in multi-page, multi-step scenarios.

Note: Current document

ation primarily covers Close Tab and Go Back operations.

<img alt="Gemini_Generated_Image_wjp8onwjp8onwjp8.png" />

**Use Cases**

* After entering multiple detail pages from a list page, closing the detail page upon completion to return to the list page for further processing.
* After clicking multiple links in the same tab, needing to go back to the previous page to continue the flow.
* Performing session cleanup in complex workflows to avoid opening too many tabs.

**Core Capabilities**

* **Close Tab:** Closes the current tab (if it is the only tab remaining, it jumps to a blank page).
* **Go Back:** Navigates back to the previous page in the browsing history within the current tab.
* Supports error handling: Select Stop or Skip if history is empty or the tab is unavailable.

**Configuration Steps**

1. Add a **Tab Operation** node and select the required operation type:
   * **Close Tab**
   * **Go Back**
2. Briefly describe the operation purpose (optional), for example:
   * "Close current detail page"
   * "Return to the job list on the previous page"
3. Configure error handling method:
   * **Stop Task:** Terminate the task when the operation cannot be executed (e.g., no history to go back to).
   * **Skip:** Ignore the error and continue executing subsequent nodes.

<img alt="PixPin_2025-12-04_14-35-25.png" />

**Recommendations**

* In [**Loop List**](/workflow/learn/node-types/loop-list-node)\*\* + \*\*[**Click Element Item**](/workflow/learn/node-types/click-element-item-node) scenarios, a common pattern is:
  * List Click → Detail Page Extraction → **Go Back / Close Tab** → Continue to next item.
* If using multi-tab mode (Visit Page selects New Tab), use Close Tab to close specific tabs after processing to remove clutter.
* Note that Tab Operation actions only affect tabs within the current session; they do not affect other browser windows on the user's local machine.


# Visit Page Node
Source: https://docs.browseract.com/workflow/learn/node-types/visit-node

Opens a specific URL in the current or a new tab to initiate an automation workflow.

Overview

The Visit Page node is used to open a target webpage in the browser and serves as the starting point for most browser automation workflows. You can specify a URL to load in either the current tab or a new tab, laying the foundation for subsequent clicks, inputs, scrolling, and data extraction.

<img alt="Gemini_Generated_Image_ogyhprogyhprogyh.png" />

**Use Cases**

* Initiating any web data scraping process (product list pages, search result pages, forum lists, etc.).
* Starting e-commerce price monitoring or content monitoring tasks.
* Serving as the entry point for a workflow, followed by actions like clicking, inputting, or scrolling.

**Core Capabilities**

* Opens a specified URL in the current tab or a new tab.
* Supports dynamic URL generation using parameters (variables).
* Configurable exception handling (e.g., terminate the task if the page fails to open).

**Configuration Steps**

1. Click **+** in the workflow and select the **Visit Page** node.
2. In the **URL** input field:
   * Directly enter or paste a complete URL (must start with `http://` or `https://`), e.g., `https://www.browseract.com/`.
   * Enter `/` to reference variables output by preceding nodes (e.g., `{{target_url}}`) for dynamic navigation.
3. Select the access mode:
   * **Current Tab Access:** Open the page in the active tab.
   * **New Tab Execution:** Open the page in a new tab to maintain environment isolation.
4. Configure exception handling as needed:
   * Set to **Stop Task** if access fails or loading fails.

<img alt="PixPin_2025-12-04_14-36-34.png" />

**Recommendations**

* Each Visit Page node should only be responsible for "opening one page"; do not mix in actions like clicking or scrolling.
* It is generally recommended to place the Visit Page node after the **Start** node and before all interaction nodes.
* For batch tasks (multiple URL lists), it is recommended to combine this with parameters and [Loop](/workflow/learn/node-types/loop-node) nodes.
* Before running officially, test the URL in a standard browser to ensure it opens correctly.


# Wait Node
Source: https://docs.browseract.com/workflow/learn/node-types/wait-node

Pauses the workflow for a specified number of seconds to allow dynamic content to finish loading.

Overview

The Wait node inserts a "waiting period" into the workflow to ensure pages or dynamic content have finished loading before subsequent operations are executed, preventing clicks or extractions from failing due to slow loading.

<img alt="Gemini_Generated_Image_lzbih0lzbih0lzbi.png" />

**Use Cases**

* Waiting for content to load after clicking "Load More" or "View More Comments."
* Waiting for a new page to render after switching pages or submitting forms.
* Pages with heavy JavaScript or significant network latency.

**Core Capabilities**

* Pauses the workflow for a specified number of seconds (e.g., 3s, 5s, 10s).
* Can be used as a pacing tool between any nodes.

**Configuration Steps**

1. Add a **Wait** node.
2. Enter the number of seconds in **Wait Time**, for example:
   * **3 seconds:** Fast-loading pages.
   * **5 seconds:** General dynamic pages.
   * **10 seconds:** Complex or slow pages.
3. At runtime, the workflow pauses at this node for the corresponding duration, then proceeds to the next node.

<img alt="PixPin_2025-12-04_14-37-25.png" />

**Recommendations**

* Recommended for use after nodes that trigger page changes, such as [**Click Element**](/workflow/learn/node-types/click-element-node), [**Visit Page**](/workflow/learn/node-types/visit-node), [**Pagination**](/workflow/learn/node-types/pagination-node), or [**Scroll**](/workflow/learn/node-types/scroll-page-node).
* Wait times should be "sufficient but not excessive"; optimize through testing.
* For pages that load in stages, use multiple shorter Wait nodes after key actions instead of one long wait.
* **Note:** Wait cannot replace element detection logic; it is merely a time compensation measure.


# Build Your First Data Scraper Workflow in 5 Minutes
Source: https://docs.browseract.com/workflow/learn/quick-start/build-your-first-data-scraper-workflow-in-5-minutes

The best way to master BrowserAct is to build a workflow yourself.

## 0. Before You Start: Core Concepts

Understanding the BrowserAct architecture moves you from **Design** to **Execution**.

* **Workflow (The Blueprint):** The complete definition of your automated process (like a digital SOP). It is a static file you design and save.
* **Node (The Building Block):** The individual instructions within a workflow. You map manual actions to specific nodes:
  * *Open URL* 👉 **Visit Page**
  * *Type* 👉 **Input Text**
  * *Click* 👉 **Click Element**
* **Task (The Runtime Instance):** A single execution record. When you hit "Run" on a specific Workflow with specific parameters, it creates a **Task** that generates your data/CSV.

**Summary:** You build a **Workflow** using **Nodes** to generate **Tasks**.

***

## 1. Open the Workflow Builder

After logging in, you’ll see the **Home** page.

1. Locate the **“AI Workflow Builder”** card in the center area.
2. Click it to open the **Workflow Build page** (the canvas where we’ll add nodes).

<img alt="image-20251203204132361.png" />

***

## 2. Example Setup & Logic

**Inputs**

* **Country:** e.g., `USA`
* **Area:** e.g., `Avalon, CA`

**Browser Actions**

1. Open `https://www.google.com/maps`
2. Search `{Country} {Area}`
3. Click search icon
4. Click **Nearby**
5. Click **Restaurant**
6. Extract list data

Output

A CSV file containing:

* `name`
* `full_address`
* `star_rating`
* `review_count`
* `average_price_per_person_range`

***

## 3. Step-by-Step Setup (Node Orchestration)

*All steps below are performed on the Workflow Build page.*

### Step 1 – Start Node: Define Input Parameters

1. On the canvas, click the **Start** node.
2. In **Input Parameters**, add:
   * **Name:** `Country` | **Default Value:** `USA`
   * **Name:** `Area` | **Default Value::** `Avalon, CA`

<img alt="image-20251203204306840.png" />

### Step 2 – Visit Page: Open Google Maps

1. Click **+** on the canvas (or right-click) and choose [**Visit Page**](/workflow/learn/node-types/visit-node).
2. Connect it after **Start**.
3. Set URL to:

   ```
   https://www.google.com/maps

   ```

<img alt="image-20251203204336274.png" />

### Step 3 – Input Text: Search for the Location

1. Add an [**Input Text**](/workflow/learn/node-types/input-text-node) node and connect it after **Visit Page**.
2. In the page preview/selector, target the **top search bar**.
3. In Text to Input, enter: Country Area

   (This references the Start parameters).

<img alt="image-20251203204349544.png" />

### Step 4 – Click Element: Navigate to Restaurants

Use one or more [**Click Element**](/workflow/learn/node-types/click-element-node) nodes to perform these three clicks in order:

1. **Search:** Click the magnifying-glass icon.
2. **Nearby:** Click the “Nearby” button.
3. **Restaurant:** Click the “Restaurant” category.

<img alt="image-20251203204434324.png" />

### Step 5 – Extract Data: Scrape the Restaurant List

1. Add an [**Extract Data**](/workflow/learn/node-types/extract-data-node) node after the last Click Element node.
2. In the left restaurant list, select **one full restaurant item** as the sample.
3. Configure fields to extract:
   * `name`
   * `full_address`
   * `star_rating`
   * `review_count`
   * `average_price_per_person_range`

<img alt="image-20251203204450694.png" />

### Step 6 – Finish: Output Data as CSV

1. Add a **Finish: Output Data** node and connect it after [**Extract Data.**](/workflow/learn/node-types/extract-data-node)
2. In the output settings:
   * **Output Format:** CSV
   * **Enable:** “Output as a file”

<img alt="image-20251203204500720.png" />

***

## 4. Publish & Run

Before executing the workflow, ensure your latest changes are saved and versioned.

1. **Publish Version:** Click the **Publish** button (top-right corner) and select **Publish as New Version** to save your current configuration.
2. **Enter Run Mode:** Click the **Run** tab (located next to the *Build* tab).
3. **Set Parameters:**
   * Country: `USA`
   * Area: `Avalon, CA`
4. **Execute:** Click **Start Run** and watch the nodes execute one by one.

<img alt="unnamed.png" />

You’re done when:

1. All steps show **Succeeded / ✔**.
2. The run result shows a **downloadable CSV file**.
3. The CSV contains rows like:

Code snippet

```
name,full_address,star_rating,review_count,average_price_per_person_range
Bluewater Avalon,306 Crescent Ave,4.3,2342,$30–50
Buffalo Nickel Inc,57 Pebbly Beach Rd,4.6,646,$20–30
...
```

<img alt="image-20251203204936979.png" />

***

## 5. Common Roadblocks (Quick Fixes)

* **CSV is empty or has very few rows:**
  * Check the sample in [**Extract Data**](/workflow/learn/node-types/extract-data-node): it should be a full list item, not a tiny sub-element.
  * **Wait for load:** Add a short [wait](/workflow/learn/node-types/wait-node) before Extract Data if the list loads slowly.
* **Click Element does nothing:**
  * Re-select the actual clickable element (button/text) in the [Click Element node](/workflow/learn/node-types/click-element-node).
  * Confirm node order: Search → Nearby → Restaurant.
* **Run error and not sure why:**
  * Check URL in Visit Page is exactly `https://www.google.com/maps`.
  * Ensure Run parameters (Country/Area) are filled.
  * Ensure no node has missing config ([Click Element](/workflow/learn/node-types/click-element-node), etc.).

> **Support:** If it still fails, contact support via [**Discord**](https://discord.com/invite/UpnCKd7GaU) with:
>
> * A short description of your goal.
> * Screenshot of the failing error.
> * Task ID of the execution.

***

## 8. Next Steps

Now that this workflow runs:

1. Reuse it with new locations

   Run again with:

   * *Country:* USA, *Area:* New York
   * *Country:* Japan, *Area:* Shibuya

**If you can build this workflow, run it successfully, and change inputs to scrape another city, you’re ready to design your own BrowserAct workflows.**

***


# Core Concepts
Source: https://docs.browseract.com/workflow/learn/quick-start/core-concepts

An overview of BrowserAct's AI-powered automation platform and its core concepts: Workflow, Node, and Task.

These three concepts form a logical hierarchy that moves from **Design** to **Execution**:

1. **Workflow:** The **Blueprint** (The complete definition of a business process).
2. **Node:** The **Execution Unit** (The individual functional steps within the process).
3. **Task:** The **Runtime Instance** (The actual execution record of a workflow).

<img alt="1764830962132_d.png" />

***

## 1. Workflow: The Process Blueprint

**Definition:** A Workflow is the end-to-end design of an automated process, representing a specific business goal.

In a business context, a Workflow is equivalent to a **Standard Operating Procedure (SOP)**. It encapsulates the complete logic, rules, and sequence of actions required to achieve a desired outcome.

### From Manual Operations to Automated Workflows

Consider a typical manual routine:

> *Open e-commerce site 👉 Search for "Laptops" 👉 Iterate through 5 pages of results 👉 Extract pricing data to CSV.*

In BrowserAct, this entire routine is consolidated into a single **Workflow** (e.g., named "Price Monitor"). Once saved, this workflow becomes a reusable asset. You can execute it today for "Laptops" and tomorrow for "Keyboards" using the same underlying logic.

***

## 2. Node: The Atomic Unit of Execution

**Definition:** A Node is a single, concrete instruction within a Workflow.

BrowserAct deconstructs complex user behaviors into granular, browser-level actions. Each component you place on the automation canvas is a **Node**.

### Mapping Manual Actions to Nodes

To automate a web task, you map your physical interactions to specific BrowserAct nodes:

| **Manual Interaction** | **BrowserAct Node** |
| :- | :- |
| Open a URL | [**Visit Page**](/workflow/learn/node-types/visit-node) |
| Type text into a field | [**Input Text**](/workflow/learn/node-types/input-text-node) |
| Click a button or link | [**Click Element**](/workflow/learn/node-types/click-element-node) |
| Scroll the viewport | [**Scroll Page**](/workflow/learn/node-types/scroll-page-node) |
| Navigate to the next page | [**Pagination**](/workflow/learn/node-types/pagination-node) |
| Copy text or data | [**Extract Data**](/workflow/learn/node-types/extract-data-node) |
| Repeat actions for a list | [**Loop**](/workflow/learn/node-types/loop-node) |

**Key Distinction:** A Workflow defines **what** the business goal is, while Nodes define **how** the browser executes each step technically.

***

## 3. Task: The Runtime Instance

**Definition:** A Task is a single, independent execution record of a Workflow.

A Workflow is a static design file; it does not perform actions until triggered. When you initiate a "Run," BrowserAct generates a **Task**. Executing the same Workflow ten times will result in ten distinct Tasks.

### Anatomy of a Task

Every Task comprises four distinct components:

1. **Inputs:** The specific parameters defined for this run (e.g., Keyword: "Nike", Max Items: 50).
2. **Execution Log:** A chronological record of which nodes were executed, including timestamps and status codes.
3. **Output Data:** The structured result generated by the run (JSON, CSV, etc.).
4. **Resource Usage:** The computational resources (Credits) consumed to complete the operation.

***

## Summary

| **Concept** | **Definition** | **Function** |
| :- | :- | :- |
| **Workflow** | The Blueprint | Defines the complete logic and business objective. |
| **Node** | The Unit | Represents a specific technical action (Click, Type, Scroll). |
| **Task** | The Instance | Represents a single execution event with specific inputs and results. |

## What's Next?

Now that you understand the core architecture, the most effective way to learn is through application. We have prepared a guide to help you deploy your first automation efficiently.

👉[**\[Go to Quick Start: Build Your First Workflow\]**](/workflow/learn/quick-start/build-your-first-data-scraper-workflow-in-5-minutes)


# Use BrowserAct in n8n.Make
Source: https://docs.browseract.com/workflow/learn/quick-start/use-browseract-in-n8n-make-zapier

Once you have a BrowserAct workflow running reliably, you can trigger it from n8n or Make and plug it into your larger automations.

<img alt="Gemini Generated Image 9q2jxk9q2jxk9q2j Jp" />

### Prerequisites

Before you start:

1. Create a BrowserAct account (if you haven't already)
2. Navigate to **Integrations& API** in BrowserAct
3. Generate an API key
4. Keep your API key ready to paste into n8n/Make

<img alt="PixPin_2025-12-04_11-13-16.png" />

***

## Using BrowserAct in n8n

BrowserAct can be used in n8n in **two ways**:

* via the **official, verified integration**\
  – see: [BrowserAct integration on ](https://n8n.io/integrations/browseract)[n8n.io](http://n8n.io)
* via the **community node** (for self-hosted / custom deployments)\
  – see: [n8n-nodes-browseract on npm](https://www.npmjs.com/package/n8n-nodes-browseract)

> The configuration inside the node is the same in spirit for both options:\
> you pick a workflow, then map inputs into its parameters, and consume its outputs.

### 1. Connect n8n to BrowserAct

**Official integration**

1. In n8n, add a **BrowserAct** node to any workflow.
2. In the node’s **Credentials** section, create a new credential.
3. Paste your BrowserAct **API Key** and save.

**Community node**

1. Install the community package `n8n-nodes-browseract` into your n8n instance (follow the instructions in the npm README).
2. Restart n8n if needed.
3. Add the **BrowserAct** node provided by the community package.
4. In its **Credentials**, paste your BrowserAct API key.

### 2. Pick the workflow to run

In the BrowserAct node’s **Parameters** panel:

* Set **Resource** to `Workflow` (or the equivalent option).
* Set **Operation** to `Run a workflow`.
* Choose **Search Workflows From**:
  * `Template Marketplace` – to use a template workflow, or
  * `My Workflows` – to use a workflow you created in BrowserAct.
* In **Workflow**, select the workflow you want to run (for example `Google Maps Scraper` or any custom workflow).

### 3. Configure the input parameters

After you select a workflow, the node’s **Input Parameters** section is generated **dynamically** from that workflow’s **Start node**.

* A maps workflow might expose: `datalimit`, `URL`, `Area`, `Keyword`.
* A research workflow might expose: `target_url`, `search_keywords`, `data_limit`.
* An e-commerce workflow might expose: `asin_list`, `marketplace`, `min_price_change`, etc.

This means:

> Different workflows → different input parameter fields in n8n.\
> You don’t define these in n8n; they come from the workflow definition in BrowserAct.

Now map your data:

* Use options like **Mapping Column Mode**, **Field to match on**, and **Values to Update** (the individual parameter fields).
* Map fields from previous nodes (sheet columns, webhook fields, CRM data, etc.) into the corresponding BrowserAct parameters (`URL`, `Area`, `Keyword`, …).

### 4. Run and use the output

* Execute the BrowserAct node (or run the whole n8n workflow).
* n8n sends your mapped inputs to BrowserAct, which runs the selected workflow.
* The node returns **structured JSON items** (one item per scraped record, or whatever your workflow outputs).

You can then:

* Write the data to **Google Sheets / databases**.
* Pass it through **Routers / IF nodes** for branching logic.
* Send **emails, Slack messages, webhooks**, or trigger any other downstream process.

<img alt="download.png" />

***

## Using BrowserAct in Make

BrowserAct also has an official integration in **Make**:\
[BrowserAct integration on Make](https://www.make.com/en/integrations/browser-act)

### 1. Connect Make to BrowserAct

1. In Make, add any **BrowserAct** module to your scenario.
2. In the module’s **Connection** field, create a new connection.
3. Paste your BrowserAct **API Key** and save.

### 2. Add a BrowserAct module to your scenario

1. In your scenario, insert a **BrowserAct** module.
2. Select the action **Run a workflow**.
3. Place it after the module that should provide context (for example a scheduler, Google Sheets, a webhook, etc.).

### 3. Select the workflow and inputs

In the BrowserAct module’s settings:

* **Search Workflows From**: choose `Template Marketplace` or `My Workflows`.
* **Workflow**: pick the workflow you want to run (for example `Google Scholar Research Scraper-0911`).

After you choose a workflow, the **Input Parameters** section is generated from that workflow’s **Start node**, just like in n8n:

* For example: `target_url`, `search_keywords`, `data_limit`, or any other inputs that workflow defines.

You can then:

* Enter fixed values (good for scheduled “same config every time” runs), or
* Map values from earlier modules (for example URL and keyword from a spreadsheet row or webhook payload).

### 4. Use the returned data

When the scenario runs:

* Make calls BrowserAct with the mapped parameters.
* BrowserAct executes the workflow and returns **bundles** of structured data to the next module.

You can then:

* Store the data in **Sheets / databases / Airtable / Notion**.
* Trigger **emails, Slack/Teams messages**, or create **CRM records**.
* Chain more modules to continue your business logic.

<img alt="PixPin_2025-12-04_11-16-24.png" />

***

In both n8n and Make, the pattern is:

* **BrowserAct**: owns the web automation logic and defines the input parameters per workflow.
* **n8n / Make**: decide when to run that workflow, where inputs come from, and how to use the outputs in your overall automation.