> ## Content Index
> Fetch the complete content index at: https://roundproxies.com/blog/llms.txt
> Use this file to discover other available public pages before exploring further.

# How to do Web Automation with Morelogin in 6 Steps
- URL: https://roundproxies.com/blog/morelogin-web-automation/
- Published: 2026-01-22T09:44:59.000Z
- Updated: 2026-10-13T03:06:36.000Z
- Description: Master Morelogin automation in 6 steps. Connect Selenium & Puppeteer to antidetect browser profiles. Complete code examples included.
- Author: Marius Bernard
- Tags: Browser Scraping, Web Scraping, MoreLogin, #dated-6971ecef26f439f88a95b33e

Standard browsers give automation away. Selenium and Puppeteer leave traces that sites read within the first few requests, and the accounts behind those scripts get flagged or banned. Antidetect browsers close that gap by running each session in an isolated profile with its own fingerprint.

[Morelogin](https://www.morelogin.com/register/?from=Roundproxies) web automation works through a local API and remote debugging ports that standard automation frameworks can connect to. Your script asks the local client to start a profile, gets back a debug port, and attaches to that browser. The profile keeps its own fingerprint, cookies, local storage, and proxy, so every automated session looks like a separate user on a separate machine.

This guide covers the setup in six steps: getting the local API running, launching and attaching to profiles, and driving them with Python and Selenium, Node.js and Puppeteer, or Playwright.

## What You'll Learn

- Setting up Morelogin's local API for automation
- Connecting Selenium to Morelogin browser profiles
- Automating with Puppeteer and Playwright
- Running headless automation for server environments
- Handling multiple profiles simultaneously

## Why Use Morelogin for Web Automation?

Standard browser automation tools leave obvious fingerprints. Websites check for WebDriver properties, automation flags, and inconsistent browser fingerprints.

Morelogin creates isolated browser profiles with real fingerprint parameters. Each profile has its own Canvas hash, WebGL renderer, fonts, screen resolution, and dozens of other attributes.

When you connect Selenium or Puppeteer to a Morelogin profile, the automation framework controls a properly fingerprinted browser. The target website sees a regular user instead of a bot.

This matters for social media management, e-commerce tasks, data collection, and any scenario where detection means an account ban.

## Step 1: Install and Configure Morelogin

Download Morelogin from the official website at morelogin.com. The application runs on Windows and macOS.

After installation, create your Morelogin account and log in. New accounts receive two free permanent browser profiles.

Before running any automation, you need to enable the API interface. Open Morelogin, click the gear icon for Settings, then navigate to the API section.

The API page displays three pieces of information: your API ID, API Key, and the local API address. The default API endpoint is `http://127.0.0.1:40000`.

Write down or copy your API credentials. You'll need these for authentication in your automation scripts.

**Important:** The API only works while Morelogin is running. Keep the application open in the background during automation tasks.

## Step 2: Create Browser Profiles for Automation

Each automation task needs a browser profile. You can create profiles manually through the interface or programmatically via the API.

For manual creation, click "New Profile" in Morelogin. Configure the following settings:

- **Browser Type:** Chrome or Firefox (Chrome recommended for Puppeteer)
- **Operating System:** Match your target platform (Windows/macOS/Android)
- **Proxy:** Add your proxy if needed (residential proxies work best)
- **Fingerprint Settings:** Leave on auto-generate for realistic fingerprints

After creating the profile, right-click it in the list. Select "Copy Browser Profile ID" to get the unique identifier you'll use in scripts.

**Bulk Profile Creation via API**

For automation at scale, create profiles through the API. Here's a Python example:

```python
import requests

API_URL = "http://127.0.0.1:40000"
HEADERS = {
    "Content-Type": "application/json",
    "X-Api-Id": "YOUR_API_ID",
    "X-Api-Key": "YOUR_API_KEY"
}

def create_profiles(count):
    payload = {
        "browserTypeId": 1,      # 1 = Chrome, 2 = Firefox
        "operatorSystemId": 1,   # 1 = Windows, 2 = macOS
        "quantity": count
    }
    
    response = requests.post(
        f"{API_URL}/api/env/create/quick",
        json=payload,
        headers=HEADERS
    )
    
    result = response.json()
    if result["code"] == 0:
        return result["data"]  # Returns list of profile IDs
    else:
        print(f"Error: {result['msg']}")
        return []

# Create 5 new profiles
profile_ids = create_profiles(5)
print(f"Created profiles: {profile_ids}")

```

This script creates profiles with default fingerprint settings. The API returns an array of profile IDs.

## Step 3: Start Profiles and Get Debug Ports

Before connecting automation frameworks, you must start the browser profile through the API. The start endpoint returns a debug port for WebSocket connections.

Here's how to start a profile and get its debug port:

```python
import requests
import time

API_URL = "http://127.0.0.1:40000"
HEADERS = {
    "Content-Type": "application/json",
    "X-Api-Id": "YOUR_API_ID",
    "X-Api-Key": "YOUR_API_KEY"
}

def start_profile(profile_id):
    payload = {"envId": profile_id}
    
    response = requests.post(
        f"{API_URL}/api/env/start",
        json=payload,
        headers=HEADERS
    )
    
    result = response.json()
    if result["code"] == 0:
        debug_port = result["data"]["debugPort"]
        print(f"Profile started on debug port: {debug_port}")
        return debug_port
    else:
        print(f"Failed to start: {result['msg']}")
        return None

def stop_profile(profile_id):
    payload = {"envId": profile_id}
    
    response = requests.post(
        f"{API_URL}/api/env/close",
        json=payload,
        headers=HEADERS
    )
    
    result = response.json()
    return result["code"] == 0

```

The `debugPort` in the response is what Selenium, Puppeteer, and Playwright use to connect. Each profile gets its own unique port.

**Pro Tip:** Always check the profile status before connecting. Use the `/api/env/status` endpoint to verify the browser is fully loaded.

```python
def check_profile_status(profile_id):
    payload = {"envId": profile_id}
    
    response = requests.post(
        f"{API_URL}/api/env/status",
        json=payload,
        headers=HEADERS
    )
    
    result = response.json()
    if result["code"] == 0:
        return result["data"]["status"]  # "running" or "stopped"
    return None

```

## Step 4: Connect Selenium to Morelogin Profiles

Selenium works with Morelogin through the Remote WebDriver. Instead of launching a new browser, you connect to the already-running profile.

Install the required packages first:

```bash
pip install selenium requests

```

Here's a complete **Morelogin automation** script using Python and Selenium:

```python
import requests
import time
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By

# Configuration
API_URL = "http://127.0.0.1:40000"
PROFILE_ID = "YOUR_PROFILE_ID"
HEADERS = {
    "Content-Type": "application/json",
    "X-Api-Id": "YOUR_API_ID",
    "X-Api-Key": "YOUR_API_KEY"
}

def start_profile(profile_id):
    """Start a Morelogin profile and return the debug port."""
    payload = {"envId": profile_id}
    response = requests.post(
        f"{API_URL}/api/env/start",
        json=payload,
        headers=HEADERS
    )
    result = response.json()
    
    if result["code"] == 0:
        return result["data"]["debugPort"]
    raise Exception(f"Failed to start profile: {result['msg']}")

def stop_profile(profile_id):
    """Stop a running Morelogin profile."""
    payload = {"envId": profile_id}
    requests.post(
        f"{API_URL}/api/env/close",
        json=payload,
        headers=HEADERS
    )

def create_driver(debug_port):
    """Create Selenium driver connected to Morelogin profile."""
    options = Options()
    options.debugger_address = f"127.0.0.1:{debug_port}"
    
    driver = webdriver.Chrome(options=options)
    return driver

def main():
    debug_port = None
    driver = None
    
    try:
        # Start the profile
        debug_port = start_profile(PROFILE_ID)
        time.sleep(3)  # Wait for browser to fully load
        
        # Connect Selenium
        driver = create_driver(debug_port)
        
        # Your automation logic here
        driver.get("https://example.com")
        print(f"Page title: {driver.title}")
        
        # Example: Fill a form
        # driver.find_element(By.ID, "username").send_keys("test")
        
        time.sleep(5)
        
    finally:
        if driver:
            driver.quit()
        stop_profile(PROFILE_ID)

if __name__ == "__main__":
    main()

```

The key is the `debugger_address` option. This tells Selenium to connect to an existing Chrome DevTools Protocol session instead of launching a new browser.

**Handling ChromeDriver Versions**

Morelogin uses its own Chromium core. The API response includes the path to a compatible WebDriver. Use this to avoid version mismatch errors:

```python
def get_webdriver_path(profile_id):
    payload = {"envId": profile_id}
    response = requests.post(
        f"{API_URL}/api/env/status",
        json=payload,
        headers=HEADERS
    )
    result = response.json()
    
    if result["code"] == 0:
        return result["data"].get("webdriver")
    return None

```

## Step 5: Automate with Puppeteer and Playwright

For Node.js projects, Puppeteer offers better performance than Selenium. Playwright supports Firefox and WebKit in addition to Chromium.

**Puppeteer Setup**

Install puppeteer-core (not the full puppeteer package):

```bash
npm install puppeteer-core axios

```

Here's a complete Puppeteer script for **Morelogin automation**:

```javascript
const puppeteer = require('puppeteer-core');
const axios = require('axios');

const API_URL = 'http://127.0.0.1:40000';
const PROFILE_ID = 'YOUR_PROFILE_ID';
const HEADERS = {
    'Content-Type': 'application/json',
    'X-Api-Id': 'YOUR_API_ID',
    'X-Api-Key': 'YOUR_API_KEY'
};

async function startProfile(profileId) {
    const response = await axios.post(
        `${API_URL}/api/env/start`,
        { envId: profileId },
        { headers: HEADERS }
    );
    
    if (response.data.code === 0) {
        return response.data.data.debugPort;
    }
    throw new Error(`Failed to start: ${response.data.msg}`);
}

async function stopProfile(profileId) {
    await axios.post(
        `${API_URL}/api/env/close`,
        { envId: profileId },
        { headers: HEADERS }
    );
}

async function main() {
    let browser = null;
    
    try {
        // Start Morelogin profile
        const debugPort = await startProfile(PROFILE_ID);
        console.log(`Profile started on port: ${debugPort}`);
        
        // Wait for browser initialization
        await new Promise(r => setTimeout(r, 3000));
        
        // Connect Puppeteer
        const browserWSEndpoint = `ws://127.0.0.1:${debugPort}`;
        browser = await puppeteer.connect({
            browserWSEndpoint,
            defaultViewport: null
        });
        
        // Get existing page or create new one
        const pages = await browser.pages();
        const page = pages[0] || await browser.newPage();
        
        // Your automation logic
        await page.goto('https://example.com');
        console.log(`Page title: ${await page.title()}`);
        
        // Example: Take screenshot
        await page.screenshot({ path: 'screenshot.png' });
        
        await new Promise(r => setTimeout(r, 5000));
        
    } finally {
        if (browser) {
            await browser.disconnect();
        }
        await stopProfile(PROFILE_ID);
    }
}

main().catch(console.error);

```

The `puppeteer.connect()` method attaches to the running browser instead of launching one. This preserves all fingerprint settings from Morelogin.

**Playwright Setup**

Playwright works similarly. Install it with:

```bash
npm install playwright-core axios

```

```javascript
const { chromium } = require('playwright-core');
const axios = require('axios');

// Same API configuration as Puppeteer example...

async function main() {
    const debugPort = await startProfile(PROFILE_ID);
    
    const browser = await chromium.connectOverCDP(
        `http://127.0.0.1:${debugPort}`
    );
    
    const context = browser.contexts()[0];
    const page = context.pages()[0] || await context.newPage();
    
    await page.goto('https://example.com');
    console.log(await page.title());
    
    await browser.close();
    await stopProfile(PROFILE_ID);
}

```

Playwright uses `connectOverCDP` instead of a WebSocket URL. The rest of the workflow remains identical.

## Step 6: Run Headless Automation on Servers

For production environments and servers, you need headless execution. Morelogin supports a headless service mode that runs without a GUI.

**Starting Headless Mode**

Launch Morelogin in headless mode from the command line:

**Windows:**

```bash
cd "C:\Program Files\MoreLogin"
start /WAIT MoreLogin.exe --headless=true --port=40000

```

**macOS:**

```bash
"/Applications/MoreLogin.app/Contents/MacOS/MoreLogin" --headless=true --port=40000

```

The `--port` parameter specifies which port the API listens on. Make sure this matches your scripts.

**Starting Profiles in Headless Mode**

Profiles can also run headless. Add the `isHeadless` parameter when starting:

```python
def start_headless_profile(profile_id):
    payload = {
        "envId": profile_id,
        "isHeadless": True
    }
    
    response = requests.post(
        f"{API_URL}/api/env/start",
        json=payload,
        headers=HEADERS
    )
    
    return response.json()

```

Headless mode requires Morelogin version 2.36.0 or higher.

## Running Multiple Profiles Simultaneously

Morelogin automation supports multi-profile workflows. Here's a pattern for parallel execution:

```python
import asyncio
import aiohttp

async def start_and_automate(session, profile_id):
    # Start profile
    async with session.post(
        f"{API_URL}/api/env/start",
        json={"envId": profile_id},
        headers=HEADERS
    ) as response:
        result = await response.json()
        debug_port = result["data"]["debugPort"]
    
    # Connect and automate
    options = Options()
    options.debugger_address = f"127.0.0.1:{debug_port}"
    driver = webdriver.Chrome(options=options)
    
    # Run your tasks...
    driver.get("https://example.com")
    
    driver.quit()
    
    # Stop profile
    async with session.post(
        f"{API_URL}/api/env/close",
        json={"envId": profile_id},
        headers=HEADERS
    ) as response:
        pass

async def main():
    profile_ids = ["profile1", "profile2", "profile3"]
    
    async with aiohttp.ClientSession() as session:
        tasks = [
            start_and_automate(session, pid) 
            for pid in profile_ids
        ]
        await asyncio.gather(*tasks)

asyncio.run(main())

```

Keep in mind the API rate limit of 60 requests per minute per endpoint. Space out your profile starts if you're running many simultaneously.

## Best Practices for Morelogin Automation

**Use Proxies Per Profile**

Each profile should have its own proxy IP. This prevents correlation between accounts. Configure proxies through the Morelogin interface or API before starting profiles.

**Add Random Delays**

Instant actions trigger bot detection. Add random pauses between interactions:

```python
import random
import time

def human_delay(min_seconds=1, max_seconds=3):
    time.sleep(random.uniform(min_seconds, max_seconds))

```

**Check Profile Status Before Connecting**

Network delays can cause connection failures. Always verify the profile is running:

```python
def wait_for_profile(profile_id, timeout=30):
    start_time = time.time()
    while time.time() - start_time < timeout:
        status = check_profile_status(profile_id)
        if status == "running":
            return True
        time.sleep(1)
    return False

```

**Clean Up Profiles**

Clear cookies and cache periodically using the API:

```python
def clear_profile_cache(profile_id):
    payload = {
        "envId": profile_id,
        "cookie": True,
        "localStorage": True,
        "indexedDB": True
    }
    
    requests.post(
        f"{API_URL}/api/env/removeLocalCache",
        json=payload,
        headers=HEADERS
    )

```

## Common Issues and Fixes

**Profile Won't Start**

Check that Morelogin is running and logged in. The API requires an active session.

**Selenium Can't Connect**

The profile might not be fully loaded. Increase the delay after starting or use the status endpoint to wait for the "running" state.

**ChromeDriver Version Mismatch**

Use the WebDriver path returned by the status API. Morelogin bundles compatible drivers for each Chromium version.

**Rate Limiting**

The API limits requests to 60 per minute per endpoint. Implement request queuing for high-volume operations.

## Final Thoughts

Morelogin automation gives you the detection evasion of an antidetect browser combined with standard automation frameworks. The local API approach means your existing Selenium or Puppeteer skills transfer directly.

Start with a single profile to test your workflow. Once it works reliably, scale up to multi-profile automation with proper proxies and delays.

The key advantage over raw browser automation is fingerprint isolation. Each Morelogin profile maintains its own browser identity across sessions, making long-term account management practical.

For high-volume scraping or data collection tasks, consider pairing Morelogin with residential proxies from Roundproxies.com to further reduce detection risk.

## FAQ

### Does Morelogin automation work on Linux servers?

Morelogin currently supports Windows and macOS only. For Linux servers, run the Morelogin client on a Windows instance and connect your scripts via the API over your local network.

### Can I use Firefox profiles with Puppeteer?

No, Puppeteer only supports Chromium-based browsers. Use Selenium or Playwright for Firefox profile automation with Morelogin.

### How many profiles can run simultaneously?

This depends on your system resources and Morelogin subscription tier. Each profile runs a full browser instance, so RAM is usually the limiting factor.

### Do I need to keep Morelogin open during automation?

Yes, the local API only functions while Morelogin is running and logged in. Use headless mode for server deployments.