No-Code Automation: Wire JustBrowser into n8n & Make (2026)

Picture a workflow that starts twelve JustBrowser profiles at 6am, hands each one to a routine task, and shuts everything down while you're still asleep. Setup time: under an hour. Lines of code written: zero.

If you can read code well enough to spot when it's broken but can't write Playwright scripts from scratch, that's a perfectly good place to start. Most multi-account browsers advertise APIs, but an API usually means code, code means developers, and developers mean budget. n8n and Make change that: drag a node, drop a node, paste an endpoint. And the REST API that JustBrowser ships stops being just for engineers.

By the end of this tutorial, you'll have a working no-code workflow that starts JustBrowser profiles on a schedule, stops them when the work is done, and logs everything to a spreadsheet. No Playwright. No Puppeteer. No Python. Just boxes and arrows.

Prerequisites

Before we start:

• JustBrowser account — the REST API is available on a subscription ($9.99/mo or $99.99/yr) or an active 7-day trial (card required). See the pricing page for full details.
• n8n or Make account — see each tool's pricing page for current plans. Both are covered below.
• Your JustBrowser API token — from the AI page in the JustBrowser app.
• A Google Sheet or Airtable base (optional) — for logging and triggering from external data.

One thing to know up front: the API is local. It's bound to 127.0.0.1 on the machine running JustBrowser, so the automation tool has to run on that same machine (self-hosted n8n is the easy route). There is no hosted API endpoint.

Basic familiarity with what HTTP requests are helps. If you've ever built a Zapier workflow, you're overqualified.

Step 1: Grab Your JustBrowser API Credentials

Open JustBrowser and go to the AI page. Generate a token if you haven't already. You'll paste it into n8n or Make as a Bearer token. The base URL is http://127.0.0.1:36542/api/v1 (the port is configurable in the app), and all your requests go there. The full endpoint list lives in the API docs.

Quick sanity check: In your terminal (or a tool like Postman), run:

curl -H "Authorization: Bearer YOUR_TOKEN" \
  http://127.0.0.1:36542/api/v1/profiles

You should get a JSON list of your profiles, wrapped in a data field (every response is enveloped like this). If you get a 401, your token's wrong. If you get an empty array, you haven't created any profiles yet — that's fine, create them in the app first.

Don't skip this check. A trailing space pasted along with the token is an easy mistake to make, and it will have you convinced the API is down at 1am. It isn't.

Step 2: Set Up Your First n8n Workflow

n8n first, Make after.

Create a new workflow

In n8n, hit "New Workflow." Name it something like "JustBrowser Daily Run."

Add a Schedule Trigger

Drag in a "Schedule Trigger" node. Configure it:

• Trigger interval: Every day
• Hour: Pick something off-peak, like 6am, so the run doesn't compete with your own work for CPU.

For testing, you can also add a "Manual Trigger" node so you can run it on demand.

Add an HTTP Request node to list profiles

Drag in an "HTTP Request" node. Configure:

• Method: GET
• URL: http://127.0.0.1:36542/api/v1/profiles
• Authentication: Header Auth
• Header name: Authorization
• Header value: Bearer YOUR_TOKEN

Connect the Schedule Trigger to this node. Run it. You should see your profiles in the output panel.

Loop through profiles

Here's where n8n shines for non-coders. The profiles arrive as one item holding a data array, so first add a "Split Out" node on the data field, then a "Split In Batches" node. This takes the array of profiles and processes them one at a time. Run them one at a time rather than in parallel — twelve browsers launching in the same second is hard on any laptop.

For each profile, you'll want to:

1. Start the profile
2. Wait for it to load
3. Let it run while the task does its work
4. Stop the profile

Add HTTP Request nodes for each action

Start profile:

• Method: POST
• URL: http://127.0.0.1:36542/api/v1/profiles/{{$json.id}}/start
• Authentication: same Bearer token
• Body (JSON): {"headless": false}

Two details matter here. The API starts profiles headless unless the body says otherwise, and a headless session has no real window, so its screen and viewport follow headless defaults. Send {"headless": false} whenever you want a visible window. And the {{$json.id}} pulls the profile ID from the current item in the loop; n8n's expression syntax is surprisingly clean once you get used to it.

The response includes a cdp_url, which is what you'd hand to Playwright or Puppeteer later if you outgrow pure no-code.

Wait node:

Add a "Wait" node. Profiles need time to fully initialize, and browsers aren't instant. Start with 30-60 seconds and adjust to your hardware.

The task itself:

This is the slot for whatever the profile is there to do: a dashboard check for a client, a scheduled export, a handoff to a script. Leave the profile running long enough for that work to finish before the stop call.

Stop profile:

• Method: POST
• URL: http://127.0.0.1:36542/api/v1/profiles/{{ $('Split In Batches').item.json.id }}/stop

By this point $json holds the start and wait output, not the profile, so pull the ID from the loop node instead. Use stop, not a browser-side close. Closing a CDP connection only disconnects; the profile keeps running until you stop it through the API.

And that's your loop. Schedule triggers it, it grabs all profiles, starts each one, waits, then stops it. Repeat daily.

Log to Google Sheets (optional)

Add a "Google Sheets" node at the end of the loop to append a row with profile name, timestamp, and status. Debugging is brutal without logs, and you'll want to know which profiles ran and when.

Step 3: The Same Thing in Make

Make's interface is cleaner but the concepts are identical. One catch: Make's scenarios run in Make's cloud, and the JustBrowser API only listens on localhost. You'll need a way to reach your machine (Make's local agent or a tunnel — neither is a supported JustBrowser path), which is why n8n on the same box is simpler.

Create a scenario

New Scenario → Add a module → Search "Schedule" → Set your interval (daily at 6am, whatever).

Add HTTP module to list profiles

HTTP → Make a request:

• URL: http://127.0.0.1:36542/api/v1/profiles
• Method: GET
• Headers: Add header, Name = Authorization, Value = Bearer YOUR_TOKEN

Add an Iterator

Make calls it an "Iterator" instead of Split In Batches. Same thing — point it at the data array from the response and it processes each item.

Add HTTP modules for start/stop

Same endpoints as n8n. In Make, you reference the current item with {{1.id}} or {{2.value.id}} depending on where the data came from. Their variable picker shows you exactly what's available.

Add delays

Make has a "Sleep" module. Add a delay between start and stop so the page actually loads and any scripts finish running. Stopping a profile two seconds after it starts means the task never got a chance.

Log results

Google Sheets module → Add a row. Include profile name, run timestamp, success/failure status.

One thing Make does better than n8n: error handling. You can add a "Resume" module that catches errors and continues the loop instead of failing the whole workflow. n8n has error handling too, but Make's visual approach is more obvious for beginners. It's the one area where Make clearly wins.

Step 4: Build an Orchestration Workflow

A scheduled start-and-stop loop is maintenance. The bigger payoff is action workflows — checking dashboards, running routine tasks across client profiles you have permission to work in.

A pattern that works for multi-client setups:

1. Trigger: New row in Google Sheets (add rows when there's work to do)
2. Data: Row contains profile ID, platform, task notes
3. Start profile: HTTP POST to the start endpoint
4. Wait: 45 seconds
5. Hand off: pass the cdp_url to whatever does the real work
6. Stop profile

The actual in-page work — typing text, uploading media, clicking buttons — still requires Puppeteer/Playwright or a dedicated tool. Annoying, but fair. The profile orchestration is pure no-code, and orchestration is a big share of the headache.

If affiliate traffic is part of what you run, ClickzProtect is a separate product for bot detection on your own campaigns. It has nothing to do with the browser, but the two sit well together.

Step 5: Trigger from External Events

The schedule trigger works for routine stuff. But what about reactive automation?

New client account added → run its first check immediately:

Set up a Google Sheets trigger (or Airtable, or Notion). When a new row appears with account details, fire the workflow for that specific profile. This is handy for onboarding — add an account to your tracking sheet, and its first check runs within minutes.

Webhook from another tool:

Both n8n and Make support webhook triggers. Your CRM closes a deal? Webhook fires, starts the profile associated with that client. Your e-commerce backend processes an order? Webhook fires, checks the seller account. (These webhooks are between your own tools. JustBrowser itself doesn't send any.)

Manual dispatch via Slack/Discord:

n8n has Slack and Discord nodes. Build a workflow that listens for a specific command (/run profile-123), parses the profile ID, and runs the task. Is that cool or slightly unhinged? Probably both.

Common Errors and How to Fix Them

401 Unauthorized on every request

Cause: Bad API token, or a team seat — seats have no API access.

Fix: Regenerate the token on the app's AI page and make sure you're signed in on the owner's subscription or trial, not a team seat.

Connection refused

Cause: JustBrowser isn't running, the port differs from 36542, or your automation tool isn't on the same machine.

Fix: Open the app, check the configured port, and run n8n locally, not inside a container (there, 127.0.0.1 is the container itself).

Profile starts but nothing seems to happen

Cause: It started headless. That's the default.

Fix: Send {"headless": false} in the start body.

Workflow runs but the task never completes

Cause: You're starting and immediately stopping without giving the profile any time.

Fix: Add a longer wait between start and stop. If it still looks idle, check that the profile has a working proxy configured.

Google Sheets logging fails silently

Cause: OAuth token expired, or your Sheets node isn't authenticated properly.

Fix: Re-authenticate the Google Sheets connection in n8n or Make. Google connections can expire, and when one does you have to reconnect it.

Next Steps

Once you've got basic automation running:

Scale to conditional logic: Use IF nodes to skip profiles that already ran today. Check your logging sheet before starting, skip if there's a recent entry.

Add notification nodes: Slack/Discord/email alerts when workflows complete — or more importantly, when they fail.

Chain workflows together: One workflow prepares profiles, triggers another for actual tasks, triggers a third for reporting. Modular beats monolithic.

Integrate analytics: If your accounts drive traffic, JustAnalytics can track what happens on your sites.

And if you want to go deeper on the API itself — Playwright, Puppeteer, headless launches, CDP integration — the developer REST API guide covers the technical details. Most operators won't need it. n8n and Make handle a large share of use cases without a line of code.

That's the point. Browser automation used to be a developer-only capability. It shouldn't have taken this long.

Frequently Asked Questions

Do I need to know how to code to automate JustBrowser?

No. JustBrowser's REST API works with n8n and Make, both of which are visual workflow builders. You drag nodes, connect them, paste your API token, and you're automating. That said, understanding basic concepts like HTTP requests, JSON responses, and webhooks helps. If you've built a Zapier workflow before, you can do this.

What's the difference between n8n and Make for browser automation?

n8n can be self-hosted, which matters here because JustBrowser's API only listens on your own machine, and it lets you run custom code nodes when you hit edge cases. Make is fully hosted with a cleaner UI for beginners, but a hosted scenario cannot reach a local API without extra plumbing. Check each tool's pricing page for current plans. For a local API, self-hosted n8n on the same machine is the simplest fit.

Can I trigger profile launches from external events like new rows in Google Sheets?

Yes. Both n8n and Make support Google Sheets triggers. When a new row appears (say, a new client account you need to check), the workflow fires an HTTP request to JustBrowser's local API to start that profile. You can also trigger from Airtable, Notion databases, webhook posts from other tools, or scheduled cron intervals.

Will this work with the JustBrowser trial?

Yes. The REST API is available on a subscription or the 7-day trial (card required). Team seats have no API access, so the token has to come from the owner's account.

---

Try JustBrowser

A multi-account browser for teams, built on a custom Chromium engine with native C++ integration, not an extension, and patched on every upstream Chromium release. 40+ identity parameters, each profile with its own cookies, storage and proxy. REST API for Playwright, Puppeteer, Selenium. 7-day card-gated trial — then $9.99/month or $99.99/year, unlimited profiles, free team seats.

Get started → · How it differs from Multilogin / GoLogin / AdsPower