Resources · Make integration

BrowserAct Make integrationAutomate BrowserAct with Make.

Need a browser job to start without you opening BrowserAct? The BrowserAct Make integration gives you 2 action modules and no trigger. This page shows which one to pick, how to link your account, and how to build a first scenario you can test right away.

Try the BrowserAct integration on MakeSee the 2 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the BrowserAct Make integration do for you?

It lets a Make scenario (the automation you build in Make, a chain of bricks called modules) start a BrowserAct workflow for you. BrowserAct is the part that clicks, types and moves through web pages; Make decides when that happens and where the result goes next. You get two action modules, and nothing that watches BrowserAct for events.

Kick off a saved browser task from another app. Say a support team logs a request in a form tool. A trigger from the form tool picks it up, then Run a Workflow starts the matching BrowserAct task and hands back an ID. You pass that ID to a spreadsheet row so anyone can see which run belongs to which request.

Keep a run log without copy and paste. Each ID that Run a Workflow returns is a bundle (one item that travels from a module to the next). Map it into Airtable or a database and you have a history of every task Make started. The Airtable Make integration page covers that side.

Reach the parts of the API with no ready-made module. The BrowserAct listing on make.com also mentions live execution screenshots and output files. Neither has a dedicated module here, so Make an API Call is the route, reusing the same connection.

What Make does not do for BrowserAct: there is no trigger, so Make never hears on its own that a task finished. Your scenario has to start from a schedule or from another app. If you build in both tools, the BrowserAct n8n integration exists too, and n8n vs Make lays out the trade-offs.

Connect

How do you connect BrowserAct to Make?

  1. 01

    Add a BrowserAct module

    In your scenario, click the +, type BrowserAct and pick Run a Workflow. In the module panel, click Create a connection. A connection is your BrowserAct account linked to Make once, then reused by both modules.

  2. 02

    Name the connection

    This field is optional, but a clear name pays off later. If you and a colleague each link your own account, a label like "BrowserAct ops team" tells you at a glance which one a module is using.

  3. 03

    Authorize, then save

    Follow what BrowserAct asks for: either approve Make on the BrowserAct page that opens, or paste the key BrowserAct gives you. Then click Save. The module panel shows the connection as selected once it works.

First scenario

Your first scenario with BrowserAct

GoalWhen the scenario's schedule comes around, Make starts a BrowserAct workflow, then uses the returned task ID in an API call.

  1. 01

    Create the scenario

    Open the Scenarios page, create a new scenario and click the big +. Since BrowserAct has no trigger, the first module will be an action that Make runs on its schedule.

  2. 02

    Add Run a Workflow

    Search for BrowserAct, choose Run a Workflow and pick your connection. Fill in the fields the module shows; once the connection works, Make can list what it is able to read from your account.

  3. 03

    Chain Make an API Call

    Click the + on the right of the first module and add Make an API Call. Map the task ID from the previous module into your request, using the endpoint BrowserAct documents for what you need.

  4. 04

    Test with Run once

    Click Run once. Make runs the scenario a single time, and shows you the bundles each module received. Check that an ID came back before going further.

  5. 05

    Schedule and switch on

    Open the clock on the first module (Scheduling). A new scenario runs every 15 minutes by default; change it to fit your needs, then switch the scenario on. Each module run counts as one operation on your plan.

Modules

The two BrowserAct modules, and when to use each

BrowserAct gives you 2 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

BrowserAct1

Make an API Call

Action

In Make“Performs an arbitrary authorized API call.”

This is the open door: you write a request to any BrowserAct API endpoint, and Make sends it with your existing connection, so no second login is needed.

When to use it
you want something the make.com listing mentions, such as a run screenshot or an output file, and no module offers it.
Watch out
you pick the endpoint and the body yourself, so keep BrowserAct's API reference open while you set it up.
BrowserAct2

Run a Workflow

Action

In Make“Starts a new task and returns an ID for tracking its progress.”

Starts a new task in BrowserAct and returns an ID you can use to follow how that task is doing.

When to use it
another app has just produced the input your browser job needs, like a new lead or a submitted form, and the task should start right after.
Watch out
what comes back is an ID, not the finished result, so reading the outcome needs another step later in the scenario.
Need help

Need help automating BrowserAct with Make?

A person reads every message.

FAQ

BrowserAct and Make: common questions

01Is the BrowserAct Make integration free?
Yes, on the Make side. BrowserAct is a standard app, available from the Free plan. That plan allows 2 active scenarios, a minimum of 15 minutes between scheduled runs, 5 minutes of execution per run, files up to 5 MB and 512 MB of data transfer. Paid plans (Core, Pro, Teams and Enterprise) drop the interval to 1 minute, lift the cap on active scenarios and allow 40 minutes of execution, with usage counted in credits each month. Your BrowserAct subscription is a separate matter that Make does not handle.
02What do you need to connect BrowserAct to Make?
A BrowserAct account and a Make account. Make's docs list no special prerequisite for this app. You add a BrowserAct module, click Create a connection, give it a name if you like, then either approve Make on the BrowserAct page or paste the key BrowserAct provides, and click Save. After that, both modules share the same connection, so you only do this once per account. If you manage several BrowserAct accounts, create one connection each and name them clearly.
03Can BrowserAct trigger a Make scenario in real time?
No. BrowserAct has no trigger module in Make, neither scheduled (Make checks at intervals) nor instant (the app calls Make by webhook). So a scenario starts some other way. The simplest is the schedule on the first module, every 15 minutes by default, at least 15 minutes on the Free plan and 1 minute on paid plans. The other option is to put a trigger from another app first, such as a new form entry, and let Run a Workflow follow it.
04What if the BrowserAct module you need is missing in Make?
Use Make an API Call. It can reach any endpoint of BrowserAct's API from your scenario, with the connection you already have. That is how you cover what the listing mentions but the two modules do not, like fetching execution screenshots or output files. Make's docs give no numeric limits for BrowserAct, so check the API reference on BrowserAct's side for anything about quotas before you build a flow that starts many tasks in a row.
05Should you use Make or n8n for BrowserAct?
It depends on how you like to work. BrowserAct exists in both tools, so the choice comes down to your team rather than the app. Make suits people who want a visual editor with a free entry plan and little setup. n8n makes sense if your team already builds its workflows there. The practical rule: start where your other automations already live, so you watch everything from one place. To test Make first, the Free plan gives you 2 active scenarios, enough to try Run a Workflow on a real task.
Same platform

Other docs you might need on this stack.

Browse all integrations