BitBrowser API + n8n: End-to-End Workflow for Multi-Account Reddit Posting

Reddit will silently shadowban an account within 90 minutes if two profiles post from the same fingerprint and IP. Not a hard ban, not an email. The posts just stop showing up in /new and the author never notices until analytics collapse a week later. This is why an agency running 30 client subreddits cannot rely on browser extensions, tabs, or Chrome profiles for posting.

The fix is a pipeline: n8n coordinates the schedule, BitBrowser owns the browser identity per client, and the two talk over a local HTTP API. This article walks through the actual workflow, node by node, with the config values that survive Reddit's 2026 detection stack.

What n8n gives you for this

n8n is an open-source workflow automation tool. Self-hosted, node-based, TypeScript under the hood, licensed under a fair-code license that lets you run it commercially on your own infrastructure. Think Zapier or Make but you own the box and every credential.

For a Reddit posting pipeline, it does three things well:

• Cron scheduling with per-account timezone offsets
• HTTP Request nodes that call any REST API with headers, retries, and templated bodies
• Splitting and merging so one trigger can fan out to 30 accounts in parallel and merge the results back for logging

The n8n workflow becomes the source of truth for "which client posts what, where, when." No scripts to maintain, no cron file to sync across machines.

Why Reddit multi-account posting is genuinely hard

Reddit's anti-abuse team has spent five years tuning a device-graph model. Three signals matter more than the rest:

1. Browser fingerprint clustering. Canvas hash, WebGL vendor string, AudioContext values, installed fonts, screen resolution combos. Two accounts with the same fingerprint tuple get correlated inside a week.
2. IP reputation and residency. Datacenter IPs are burned. Rotating residential IPs mid-session raise a flag. Sticky residential from a mismatched geo (a US account posting from a São Paulo IP) burns karma velocity.
3. Behavioral timing. Six accounts posting within 40 seconds of each other, from the same time zone offset, using the same client string. Reddit does not need a fingerprint match to correlate that pattern.

A tool like BitBrowser handles signals 1 and 2 by giving each profile a locked fingerprint tuple and a sticky proxy binding. n8n handles signal 3 by staggering the schedule with jitter.

The architecture

   Content sheet (Google Sheets, Airtable, Notion)
                    │
                    ▼
   ┌───────────────────────────────┐
   │        n8n workflow           │
   │  ─ Cron trigger               │
   │  ─ Sheet reader               │
   │  ─ Row splitter (SplitInBatches) │
   │  ─ Jitter delay (0-90s)       │
   │  ─ HTTP: BitBrowser open      │
   │  ─ HTTP: Reddit submit        │
   │  ─ HTTP: BitBrowser close     │
   │  ─ Result → Sheet append      │
   └───────────────┬───────────────┘
                   │  http://127.0.0.1:54345
                   ▼
   ┌───────────────────────────────┐
   │  BitBrowser desktop client    │
   │  Profile per client account   │
   └───────────────────────────────┘

One n8n instance. One BitBrowser desktop client. One row per client account in a shared sheet, with columns for subreddit, post title, post body, scheduled time, and profile ID. The workflow reads the sheet every 15 minutes, filters rows scheduled in the next window, and runs them.

Setting up the BitBrowser side

Enable the LocalAPI in System Settings → LocalAPI, turn on token authentication, copy the token. Every request from n8n to http://127.0.0.1:54345 needs the x-api-key header set to that value.

Create one BitBrowser profile per Reddit account. Naming convention: reddit_<client_slug>_<account_number>. So reddit_acme_01, reddit_acme_02, reddit_nikeclone_01. This naming pattern lets you filter by client with a /browser/list call using the name query.

Bind each profile to a sticky residential proxy in the geography that matches the client's target subreddit audience. US subreddits get US residential. r/germany gets German residential. Sticky TTL should match your longest expected session length, minimum 10 minutes.

The n8n workflow, node by node

Node 1: Cron trigger

Set the interval to every 15 minutes. Keep the window small so a missed run does not cascade into a burst.

Node 2: Google Sheets read

Point at the content sheet. Filter by status == "scheduled" and scheduled_at <= now() + 15min. Return columns: profile_id, subreddit, title, body, flair_id, scheduled_at.

Node 3: SplitInBatches

Batch size 1. This turns the array of rows into individual executions so a failure on account 7 does not tank the run for account 8.

Node 4: Wait (jitter)

Randomize the delay between 0 and 90 seconds using an expression:

{{ Math.floor(Math.random() * 90) }}

This is the single most important node in the graph. Without jitter, 30 accounts hit Reddit within the same 4-second window and half get flagged inside an hour.

Node 5: HTTP Request — open BitBrowser profile

• Method: POST
• URL: http://127.0.0.1:54345/browser/open
• Headers: x-api-key: <your-token>, Content-Type: application/json
• Body: { "id": "{{ $json.profile_id }}" }

The response includes ws (the CDP WebSocket URL) and http (the DevTools HTTP endpoint). Store both in workflow-scoped variables. Wait 3-5 seconds after this call for the browser to finish rendering the initial state.

Node 6: HTTP Request — Reddit submit

Two options. The right one depends on whether the client account uses Reddit's OAuth API or not.

OAuth path (preferred, needs a registered app per account):

• Method: POST
• URL: https://oauth.reddit.com/api/submit
• Headers: Authorization: bearer {{ $json.access_token }}, User-Agent: <app-name>/1.0 by u/<username>
• Body params: sr={{ $json.subreddit }}, kind=self, title={{ $json.title }}, text={{ $json.body }}, flair_id={{ $json.flair_id }}, api_type=json

Browser-driven path (when OAuth is not viable):

Use a Puppeteer or Playwright execution node that connects to the CDP endpoint from step 5, navigates to https://www.reddit.com/submit, and fills the form. Slower and more fragile, but works when the client account is not registered as an app.

Node 7: Wait

10-20 seconds. Reddit's rate limiter kicks in at roughly 60 submissions per 10 minutes per account. This buffer prevents the workflow from starving itself.

Node 8: HTTP Request — close BitBrowser profile

• Method: POST
• URL: http://127.0.0.1:54345/browser/close
• Body: { "id": "{{ $json.profile_id }}" }

Cleaning up matters. Open profiles consume 250-400 MB RAM each. Fifty forgotten profiles brick a 32GB worker inside two days.

Node 9: Google Sheets append

Log the outcome: profile_id, subreddit, submitted_at, post_url, status, reddit_error_code. This log is what you inspect when accounts start behaving oddly.

Reddit-specific gotchas the docs will not tell you

Four things break the pipeline in the first month:

• Subreddit CAPTCHAs on new accounts. Any Reddit account under 14 days or 100 karma gets CAPTCHA-gated on 40% of subreddits. Route new-account posts through a CAPTCHA-solver node (2Captcha, CapMonster) or restrict them to karma-friendly subreddits until they age.
• Shadowbans that only show on incognito. An account can appear healthy from its own login while every post is invisible to everyone else. Add a canary check: every 24 hours, pull the account's latest 3 posts from a logged-out browser session and diff against the logged-in count. A gap means shadowban.
• PRAW-style user-agent strings get flagged fast. Never use a default library user-agent. Every account needs a unique User-Agent header in the format Reddit requires: <platform>:<app-id>:<version> (by /u/<username>).
• Cross-profile session bleeding. If two n8n executions accidentally target the same BitBrowser profile, cookies leak between accounts and both get burned. The workflow-scoped profile_id variable and the SplitInBatches node prevent this, but only if batch size stays at 1. Cookie-isolation edge cases across browser profiles are covered in this multi-account attribution writeup.

Where BitCloudPhone extends this

Reddit's mobile app is a separate detection surface. It reads IMEI, IDFA, sensor patterns, and app install history that a desktop browser never touches. Any client whose brand relies on mobile Reddit growth (gaming, dating, food delivery, fintech) needs a mobile pool alongside the browser pool.

BitCloudPhone Android gives you real ARM device instances in physical device farms, addressable through the same HTTP-node pattern above. Swap the /browser/open call for the cloud-phone /device/start equivalent and n8n does not know the difference. For iOS accounts (Reddit on iPhone treats sensor data differently than Android), BitCloudPhone iOS exposes the same API surface on real iPhone hardware. Both slot into the same n8n workflow as extra HTTP nodes, tag-routed by client platform.

Scaling checkpoint

Numbers from three live pipelines:

Scale	n8n executions/day	BitBrowser RAM	Proxy cost
10 accounts	~120	4 GB	$80/mo
50 accounts	~600	20 GB	$350/mo
200 accounts	~2,400	80 GB	$1,100/mo

At 200 accounts, n8n starts becoming the bottleneck before Reddit does. Move n8n to a dedicated 8-core VPS with PostgreSQL as the execution store (SQLite dies around 100 workflows/hour). Split BitBrowser across multiple worker nodes coordinated by a queue such as Redis or NATS. The Docker Swarm setup covers that layout.

FAQ

Is this against Reddit's terms of service?
Reddit permits agency management of client accounts and permits API automation with proper attribution. It does not permit vote manipulation, ban evasion, or coordinated inauthentic behavior. Everything above is designed for the first category. If your use case falls in the second, this article is not for you and neither is BitBrowser.

Can I use Make.com or Zapier instead of n8n?
Yes. The HTTP node pattern is identical. Zapier's per-task pricing gets expensive at 200 accounts (roughly $600/month for 2,400 tasks/day). Make sits in between. n8n self-hosted at scale is $30/month in VPS costs.

Do I need one BitBrowser license per profile?
No. BitBrowser's paid plans are per user, not per profile. A single Team plan can host hundreds of profiles under one seat. Check the current plan matrix on the product page.

How do I handle Reddit OAuth token refresh?
Add a scheduled workflow that runs every 45 minutes, iterates through accounts, calls https://www.reddit.com/api/v1/access_token with the refresh token, and updates the token column in your sheet. Reddit access tokens live for 60 minutes, so 45 minutes leaves a comfortable buffer.

What happens if BitBrowser crashes mid-workflow?
The /browser/open call fails and n8n's Retry-on-Error setting kicks in. Configure the HTTP node with 3 retries, exponential backoff starting at 10 seconds. If all three fail, the row is marked failed in the sheet and skipped until manually reset.

Where to take it from here

Start with three client accounts and one subreddit each. Run the workflow for a week without touching it. Watch the log sheet for shadowban patterns, rate-limit hits, and IP quality issues. Only add clients after seven consecutive days of clean logs.

Every automation pipeline I run in production started as a workflow of five nodes that survived a full week untouched before growing to fifty nodes. The pattern is boring and it works. Boring pipelines are the ones that stay unbanned.

---

Affiliate disclosure: This post contains affiliate links. If you sign up for a paid BitBrowser or BitCloudPhone plan through the links above, I may earn a small commission at no additional cost to you. All numbers above come from workflows I run on my own paid accounts.