The Programmable Web: Inside NTXM Browser Mini's REST Automation API

Web browsing has traditionally been designed as a unidirectional, human-centric visual experience. When developers need to automate interactions—whether for scraping data, running tests, or fueling AI agents—they are forced to wrap standard browsers in heavy, fragile orchestration frameworks like Puppeteer, Playwright, or Selenium.

These frameworks require launching headless browser processes, managing platform-specific driver binaries, and running heavy scripts that consume significant system memory.

NTXM Browser Mini introduces an architectural alternative. Built with C++, Qt 6, and the Chromium Embedded Framework (CEF), it combines the rendering compliance of Chromium with a native desktop shell. Crucially, it embeds a multi-threaded REST automation server directly inside the browser process, exposing tab lifecycle and content controls over a simple local HTTP interface.

The Overhead of Traditional Browser Orchestration

Orchestrating standard browsers through external drivers introduces major layers of operational complexity.

First, there is the dependency overhead. Setting up Selenium or Playwright requires specific WebDrivers or browser bundles matching the host operating system. A version mismatch between the installed browser and the driver library often halts automated jobs.

Second, there is the resource cost. Running headless Chromium instances through Node.js or Python requires spawning heavy child processes. Each instance allocates extensive memory pools, leading to performance degradation when running concurrent scripts.

Third, standard consumer browsers are filled with telemetry and background processes—such as auto-update checks, tracking scripts, and sync engines—that generate unwanted network requests.

NTXM Browser Mini addresses these points directly by embedding a cpp-httplib server on a background thread. Rather than orchestrating a browser from the outside, the automation script sends standard HTTP requests directly to the running application on port 9090.

Under the Hood: C++, Qt 6, and CEF

The application separates its core operations into distinct execution boundaries to guarantee a highly responsive UI:

Qt 6 UI Shell: Handles native desktop window frames, tab layouts, and native keyboard inputs.
Chromium Embedded Framework (CEF): Manages web standard rendering, GPU-accelerated page loads, and sandboxed execution.
Background Automation Thread: Listens for incoming HTTP requests on a detached thread, executing actions on the main Qt thread using thread-safe signal-slot connections.

This architecture ensures that programmatic navigation commands do not block the UI loop, allowing developers to watch the automation execute in real time without stutter or crashes.

The REST Automation API: Control Blueprint

By default, the internal REST server listens at http://127.0.0.1:9090. Every endpoint managing page content supports targeting specific tabs using query parameters:

id: The unique lifetime ID of the tab (e.g., /tab?id=2).
index: The 0-based ordering/position of the tab (e.g., /tab?index=0).
Default: If neither parameter is specified, it targets the first tab (index 0).

Tab Management APIs

1. List All Open Tabs

Endpoint: GET /tabs
Description: Retrieves a JSON array containing details of all open tabs.
Request Format: None.

Examples:

cURL:
BASH
```
curl http://127.0.0.1:9090/tabs
```

Python:

PYTHON

import requests
tabs = requests.get("http://127.0.0.1:9090/tabs").json()
print(tabs)

Response Format (JSON):

JSON

[
  {
    "id": 1,
    "index": 0,
    "title": "Google",
    "url": "https://www.google.com",
    "active": true
  },
  {
    "id": 2,
    "index": 1,
    "title": "GitHub",
    "url": "https://github.com",
    "active": false
  }
]

2. Get Specific Tab Information

Endpoint: GET /tab
Description: Retrieves details for a specific resolved tab using either id or index.
Query Parameters:
- id (optional): Unique lifetime ID of the tab.
- index (optional): 0-based position of the tab.

Examples:

By Index:
BASH
```
curl http://127.0.0.1:9090/tab?index=0
```
By Unique ID:
BASH
```
curl http://127.0.0.1:9090/tab?id=2
```
Default (First Tab):
BASH
```
curl http://127.0.0.1:9090/tab
```

Response Format (JSON):

JSON

{
  "id": 2,
  "index": 1,
  "title": "GitHub",
  "url": "https://github.com",
  "active": false
}

3. Open a New Tab

Endpoint: POST /new_tab
Description: Opens a new tab, optionally navigating it to a specified URL immediately.
Query Parameters:
- url (optional): URL destination.
Request Body (optional): Plain text URL destination (used if url query parameter is omitted).

Examples:

With URL in Request Body:

BASH

curl -X POST http://127.0.0.1:9090/new_tab -d "https://news.ycombinator.com"

With URL via Query Param:

BASH

curl -X POST "http://127.0.0.1:9090/new_tab?url=https://github.com"

Blank Tab:

BASH

curl -X POST http://127.0.0.1:9090/new_tab

Response Format (JSON): Returns the newly created tab details.

JSON

{
  "id": 3,
  "index": 2,
  "title": "New Tab",
  "url": "about:blank",
  "active": true
}

4. Close Tab

Endpoint: POST /close_tab
Description: Closes the specified tab. If the last remaining tab is closed, the browser automatically spawns a new default blank tab to keep the window active.
Query Parameters:
- id (optional): Unique lifetime ID of the tab.
- index (optional): 0-based position of the tab.

Examples:

Close by ID:

BASH

curl -X POST http://127.0.0.1:9090/close_tab?id=2

Close by Index:

BASH

curl -X POST http://127.0.0.1:9090/close_tab?index=0

Close Active Tab (Default):

BASH

curl -X POST http://127.0.0.1:9090/close_tab

Response Format (Plain Text): "OK" or an error string.

5. Switch Active Tab

Endpoint: POST /activate_tab
Description: Focuses the browser interface on the targeted tab, bringing it to the foreground.
Query Parameters:
- id (optional): Unique lifetime ID.
- index (optional): 0-based position.

Examples:

Activate by Index:

BASH

curl -X POST http://127.0.0.1:9090/activate_tab?index=1

Activate by ID:

BASH

curl -X POST http://127.0.0.1:9090/activate_tab?id=3

Response Format (Plain Text): "OK".

6. Navigate Tab to URL

Endpoint: POST /navigate
Description: Triggers asynchronous web navigation on the target tab to the specified URL.
Query Parameters:
- id (optional): Unique lifetime ID.
- index (optional): 0-based position.
Request Body: Plain text URL destination.

Examples:

Navigate First Tab (Default):

BASH

curl -X POST http://127.0.0.1:9090/navigate -d "https://github.com"

Navigate Tab by Index:

BASH

curl -X POST "http://127.0.0.1:9090/navigate?index=1" -d "https://wikipedia.org"

Navigate Tab by ID:

BASH

curl -X POST "http://127.0.0.1:9090/navigate?id=3" -d "https://news.ycombinator.com"

Response Format (Plain Text): "OK".

7. History Control (Back, Forward, Reload)

Endpoints:
- POST /back
- POST /forward
- POST /reload
Description: Emulates browser navigation commands on the targeted tab.
Query Parameters:
- id (optional): Unique lifetime ID.
- index (optional): 0-based position.

Examples:

Reload Tab by ID:

BASH

curl -X POST http://127.0.0.1:9090/reload?id=2

Go Back on First Tab:

BASH

curl -X POST http://127.0.0.1:9090/back?index=0

Go Forward:

BASH

curl -X POST http://127.0.0.1:9090/forward?index=0

Response Format (Plain Text): "OK".

8. Retrieve Current URL

Endpoint: GET /url
Description: Returns the current URL of the targeted tab as plain text.
Query Parameters:
- id (optional): Unique lifetime ID.
- index (optional): 0-based position.
Examples:
- Get First Tab URL (Default):
  BASH
```
curl http://127.0.0.1:9090/url
```
- Get URL for Tab Index 1:
  BASH
```
curl http://127.0.0.1:9090/url?index=1
```
Response Format (Plain Text): The active URL (e.g., https://github.com).

9. Retrieve HTML Source Content

Endpoint: GET /content
Description: Extracts the current raw HTML page source loaded in the targeted tab.
Query Parameters:
- id (optional): Unique lifetime ID.
- index (optional): 0-based position.

Examples:

Get Content from Tab 1:

BASH

curl http://127.0.0.1:9090/content?index=0

Get Content from Tab by ID:
BASH
```
curl http://127.0.0.1:9090/content?id=2
```

Response Format (Plain Text): Raw HTML string (e.g., <!DOCTYPE html><html>...).

10. Navigate and Wait for Page Load

Endpoint: POST /navigate_content
Description: Navigates to a URL, blocks the HTTP response until the document has completely finished loading in the Chromium instance (or the optional delay has expired), and immediately returns the final HTML page source.
Query Parameters:
- id (optional): Unique lifetime ID.
- index (optional): 0-based position.
- delay (optional): Milliseconds to wait before returning the page HTML (e.g., delay=1500 for client-rendered React/Vue sites).
- skip_wait (optional): Set to true to skip waiting for the CEF load-completion trigger.
Request Body: Plain text URL destination.

Examples:

Default (Waits for CEF Load Trigger):

BASH

curl -X POST http://127.0.0.1:9090/navigate_content -d "https://github.com"

With Custom Delay (For Single Page Applications):

BASH

curl -X POST "http://127.0.0.1:9090/navigate_content?delay=2000" -d "https://news.ycombinator.com"

Target Specific Tab and Skip Load Wait:

BASH

curl -X POST "http://127.0.0.1:9090/navigate_content?id=2&delay=1000&skip_wait=true" -d "https://wikipedia.org"

Response Format (Plain Text): Raw HTML string.

11. Health Status Check

Endpoint: GET /status
Description: Simple lightweight health check endpoint to verify that the browser automation API is alive and reachable.
Request Format: None.
Example:
BASH
```
curl http://127.0.0.1:9090/status
```
Response Format (Plain Text): "running".

Orchestration Blueprint: Python Automation

Because the browser exposes standard HTTP endpoints, orchestration requires no specialized libraries. You can write your script in Python using only the requests package:

PYTHON

import requests
import json
import time

BASE_URL = "http://127.0.0.1:9090"

def run_automation():
    # 1. Check if the browser server is active
    try:
        status = requests.get(f"{BASE_URL}/status").text
        if status != "running":
            print("Browser automation server is not running.")
            return
    except requests.exceptions.ConnectionError:
        print("Could not connect to NTXM Browser Mini. Ensure it is open.")
        return

    print("Connected to NTXM Browser Mini. Starting workflow...")

    # 2. Open a new tab and navigate to Hacker News
    new_tab_res = requests.post(f"{BASE_URL}/new_tab", data="https://news.ycombinator.com")
    new_tab = new_tab_res.json()
    tab_id = new_tab.get("id")
    print(f"Opened new tab (ID: {tab_id})")

    # 3. Retrieve HTML source content
    time.sleep(2)  # Allow page to settle
    html_content = requests.get(f"{BASE_URL}/content?id={tab_id}").text
    
    # 4. Extract titles (simple string slicing for demonstration)
    print("\n--- Top Stories ---")
    for line in html_content.split("\n"):
        if 'class="titleline"' in line:
            title_part = line.split('">')[2].split('</a>')[0]
            print(f"• {title_part}")

    # 5. Clean up by closing the created tab
    requests.post(f"{BASE_URL}/close_tab?id={tab_id}")
    print(f"\nClosed tab (ID: {tab_id}). Workflow complete.")

if __name__ == "__main__":
    run_automation()

This script is extremely lightweight, requires no browser drivers, runs on any machine with Python installed, and executes instantly.

Privacy-First Local Execution

Moving automation workflows to local desktop infrastructure is a key security and compliance strategy.

When scraping research data, analyzing files, or automating workflows through public cloud services, data traverses third-party servers. This raises regulatory concerns for fields managing sensitive personal, financial, or healthcare records.

NTXM Browser Mini executes all rendering and REST queries locally on your workstation. No analytics logs or network events leave the system. This offline-first posture guarantees that proprietary scripts and private browser states remain entirely under your control.

Conclusion

By embedding a REST server directly inside a C++/CEF application, NTXM Browser Mini removes the friction points of modern web automation. It eliminates driver mismatches, cuts resource overhead, and provides clean HTTP endpoints that can be reached from any programming environment.

Whether you are scraping structured data, conducting local testing workflows, or supplying live DOM contexts to local AI agents, NTXM Browser Mini turns the web browser into programmable local infrastructure.

Browser Mini — ntxm.org

The Programmable Web: Inside NTXM Browser Mini's REST Automation API

The Programmable Web: Inside NTXM Browser Mini's REST Automation API

The Overhead of Traditional Browser Orchestration

Under the Hood: C++, Qt 6, and CEF

The REST Automation API: Control Blueprint

Tab Management APIs

1. List All Open Tabs

2. Get Specific Tab Information

3. Open a New Tab

4. Close Tab

5. Switch Active Tab

Navigation & Content Retrieval APIs

6. Navigate Tab to URL

7. History Control (Back, Forward, Reload)

8. Retrieve Current URL

9. Retrieve HTML Source Content

10. Navigate and Wait for Page Load

11. Health Status Check

Orchestration Blueprint: Python Automation

Privacy-First Local Execution

Conclusion

Connect