Standard browser automation is easy to detect. The moment you run a raw Selenium, Playwright, or Puppeteer script against a platform with real bot detection, you expose dozens of signals: headless browser flags, missing browser APIs, automation-specific JavaScript properties, and fingerprint inconsistencies that detection systems score against you in milliseconds.

The solution is not to add a stealth plugin and hope for the best. It is to run your automation inside a real, isolated browser profile with a genuine browser fingerprint and a clean residential IP. That is exactly what MultiLogin makes possible, and why it has become the standard infrastructure layer for serious browser automation at scale.

This guide covers how MultiLogin works with Selenium, Playwright, and Puppeteer, how to choose the right framework for your use case, and the key principles behind building automation workflows that stay completely undetected.

Why Standard Automation Gets Detected

Before looking at the solution, it helps to understand the problem precisely. Platforms and anti-bot systems like Cloudflare, DataDome, and PerimeterX do not just block known bot IPs. They run JavaScript challenges that probe your browser environment for dozens of signals that distinguish automated traffic from real users.

A standard headless Chromium instance running Playwright or Puppeteer fails these checks in several ways:

• navigator.webdriver is set to true in automated browsers, a flag every modern detection system checks immediately
• Missing browser APIs that real browsers expose, like chrome.runtime, are absent in headless mode
• Canvas and WebGL fingerprints are inconsistent with any known real-world device configuration
• Font enumeration returns an empty or minimal list, unlike real user environments
• Behavioral signals like mouse movement patterns, scroll physics, and click timing can all look robotic
• Datacenter IPs used by most automation setups are flagged immediately by ASN databases

The stealth plugins available for each framework, like puppeteer-extra-plugin-stealth or playwright-stealth, patch some of these leaks. But they are reactive fixes against static checks. Modern detection systems evolve constantly and check dozens of additional signals those plugins do not cover.

How MultiLogin Automation Works

MultiLogin exposes a REST API that lets you control browser profiles programmatically. The flow is straightforward: your script authenticates with the MultiLogin API, launches a specific browser profile, retrieves the WebSocket debugging port that profile is running on, and then connects your automation framework to that port using the standard remote WebDriver or CDP protocol.

From that point, your Selenium, Playwright, or Puppeteer code runs exactly as normal. The only difference is that instead of driving a default headless Chromium instance, it is driving a MultiLogin Mimic browser (Chrome-based) or Stealthfox browser (Firefox-based) with a real, stable fingerprint baked in at the engine level.

The Automation Flow Step by Step

Selenium with MultiLogin

Selenium is the oldest and most widely used browser automation framework, launched in 2004. It uses the WebDriver protocol and has official bindings for Java, Python, C#, Ruby, JavaScript, and more. For MultiLogin automation, Selenium connects via RemoteWebDriver pointed at the profile's local port.

Here is what the core connection looks like in Python:

import requests
from selenium import webdriver
from selenium.webdriver.chrome.options import Options

# Step 1: Authenticate and get token
token = get_token("[email protected]", "your_password")

# Step 2: Start profile and get port
port = start_profile(token, FOLDER_ID, PROFILE_ID, "selenium")

# Step 3: Connect Selenium to running profile
options = Options()
options.add_experimental_option("debuggerAddress", f"localhost:{port}")
driver = webdriver.Chrome(options=options)

# Step 4: Automate as normal
driver.get("https://example.com")
print(driver.title)

Selenium works with both Mimic (Chrome-based) and Stealthfox (Firefox-based) MultiLogin profiles. It is the best choice if your team already has Selenium expertise, your codebase is in Java or Python, or you need to integrate with existing test infrastructure like Selenium Grid.

Playwright with MultiLogin

Playwright was created by Microsoft in 2020 and has grown rapidly, now boasting over 61,000 GitHub stars and 4 million+ weekly NPM downloads. It connects via the Chrome DevTools Protocol (CDP) and offers native async support, automatic waiting, and multi-browser support including Chrome, Firefox, and WebKit (Safari).

For MultiLogin, Playwright connects to the running Mimic profile using chromium.connectOverCDP():

const { chromium } = require('playwright');

// Step 1: Start profile via MultiLogin API (returns port)
const port = await startProfile(token, folderId, profileId, 'playwright');

// Step 2: Connect Playwright to running profile
const browser = await chromium.connectOverCDP(`http://localhost:${port}`);
const context = browser.contexts()[0];
const page = context.pages()[0];

// Step 3: Automate as normal
await page.goto('https://example.com');
console.log(await page.title());

Note that Playwright only supports Mimic (Chrome-based) profiles in MultiLogin. Stealthfox (Firefox) is not currently compatible with Playwright. Playwright is ideal for teams that want clean, modern async code, need automatic waiting without explicit waits, or are working on complex multi-page flows.

Puppeteer with MultiLogin

Puppeteer is a Node.js library developed by Google that controls Chromium via the Chrome DevTools Protocol. Like Playwright, it connects to the running MultiLogin Mimic profile via CDP using puppeteer.connect():

const puppeteer = require('puppeteer');

// Step 1: Start profile via MultiLogin API (returns port)
const port = await startProfile(token, folderId, profileId, 'puppeteer');

// Step 2: Connect Puppeteer to running profile
const browser = await puppeteer.connect({
    browserWSEndpoint: `ws://localhost:${port}`
});
const page = (await browser.pages())[0];

// Step 3: Automate as normal
await page.goto('https://example.com');
console.log(await page.title());

Puppeteer also only works with Mimic (Chrome-based) profiles. It is a strong choice for scraping tasks where you need lightweight execution and are already working in a Node.js environment. For scraping specifically, Puppeteer's resource blocking capability makes it fast and efficient on bandwidth.

Selenium vs Playwright vs Puppeteer: Which to Choose?

All three frameworks work with MultiLogin and all three produce undetectable automation when running inside a real MultiLogin profile. The choice depends on your language preference, existing infrastructure, and what you are actually automating.

If you are starting fresh in 2025, Playwright is the recommended choice for most MultiLogin automation work. Its automatic waiting removes a major source of flaky automation, the async-first design handles concurrent multi-profile execution cleanly, and its syntax is the most readable of the three. Selenium remains the right call for teams with deep existing infrastructure or a need for Java-based scripting. Puppeteer is ideal for lightweight, fast scraping tasks in Node.js.

Headless Mode: Running Automation Without a Visible Browser

MultiLogin supports headless mode for all three frameworks, which runs the browser without a visible UI. This reduces system resource usage significantly and speeds up execution, especially when running many parallel profiles on a single machine or a VPS.

The critical difference between standard headless Chromium and MultiLogin in headless mode is that MultiLogin's headless browser still carries the full real browser fingerprint. Standard headless Chromium exposes itself through missing APIs and unusual fingerprint signals. MultiLogin in headless mode masks all of these, making the session completely indistinguishable from a real browser at the fingerprint level.

In headless mode, you can also skip loading unnecessary resources like images, CSS, and third-party scripts to reduce bandwidth usage and speed up execution, particularly useful when scraping at scale across hundreds of profiles simultaneously.

Practical Use Cases for MultiLogin Automation

Key Best Practices for Undetectable Automation

Even with MultiLogin handling the fingerprint and IP layer, your automation behavior matters. Here are the principles that separate undetectable automation from scripts that eventually get flagged:

• Simulate human-like timing. Add random delays between actions rather than firing requests as fast as the framework allows. Real users do not click elements at perfectly consistent 50ms intervals. Vary delays between 500ms and 3 seconds for most interactions.
• Warm up profiles before heavy tasks. New profiles that immediately perform high-volume actions look suspicious. Script a warm-up phase that browses a few pages organically before performing the target task.
• Use session persistence. MultiLogin saves cookies and session state per profile. Design your scripts to resume from saved sessions rather than logging in fresh every run. Persistent sessions look more like returning users.
• One profile per account, strictly. Never run two accounts from the same profile in the same session. The whole anti-detection benefit of MultiLogin depends on each profile maintaining a single, consistent identity.
• Match proxy location to profile fingerprint. MultiLogin does this automatically when using its built-in proxies. If you bring your own proxies, verify that the timezone, language, and WebRTC settings in the profile match the proxy's geographic location.
• Handle CAPTCHAs gracefully. Even with great fingerprints and proxies, some workflows encounter CAPTCHAs. Build retry logic and human-in-the-loop handling for these cases rather than forcing automated CAPTCHA solving, which itself can be a detection signal.

Getting Started with MultiLogin Automation

MultiLogin's automation API is available on all subscription plans. The official documentation provides ready-to-run example scripts for Selenium (Python), Playwright (JavaScript), and Puppeteer (JavaScript) that you can plug your credentials and Profile IDs into and run immediately.

The setup process for each framework is:

1. Install the relevant framework: pip install selenium for Python, or npm install playwright / npm install puppeteer for Node.js
2. Get your MultiLogin account credentials, Folder ID, and Profile ID from the dashboard
3. Copy the relevant MultiLogin example script from the official docs
4. Insert your credentials and IDs, run the script, and verify the profile launches and your automation connects
5. Build your custom automation logic on top of the working connection

For teams running Docker or VPS environments, MultiLogin also supports Docker-based deployments, which makes it straightforward to scale automation across multiple machines with consistent profile management.

Final Thoughts

The combination of MultiLogin with Selenium, Playwright, or Puppeteer is the production-grade setup for browser automation that needs to survive real detection systems. Standard automation frameworks are powerful tools. But without a real browser fingerprint and clean residential proxies behind them, they are always one detection update away from being blocked.

MultiLogin solves this at the infrastructure level. Your automation code runs unchanged. The fingerprint, IP alignment, and session isolation are handled by the platform. The result is automation that looks, at every detectable layer, like a real human user on a real device.

Use our MultiLogin coupon codes to get started at up to 50% off. Code MEGA50 gives 50% off the full antidetect browser platform including full automation API access. Also see our guide on what an antidetect browser is and how it works if you want the full foundation before diving into automation.