ruyiPage: Best Firefox Browser Automation for Devs in 2026

What Is ruyiPage?

ruyiPage is a Python Firefox browser automation framework built by LoseNine for engineers doing AI analysis and data capture, and the README documents 10+ capability areas spanning navigation, events, network control, cookies, downloads, screenshots, and PDF export. ruyiPage is one of the best Browser Automation tools for Firefox devs who need WebDriver BiDi, native-looking input, and packet interception on high-friction sites.

It is not trying to be a generic cross-browser wrapper. The design is Firefox-first, with explicit support for isTrusted-style actions, fingerprint-browser takeover, and a workflow that fits login flows, anti-bot pages, and session-heavy collectors.

Quick Overview

Who Should Use ruyiPage?

• Automation engineers dealing with Cloudflare, hCaptcha, DataDome, Outlook, Google Mail, or similar gated flows that punish synthetic interaction.
• Python developers who want a higher-level launch() and FirefoxPage API instead of hand-rolling protocol code.
• Data capture teams that need request and response interception, collectors, and isolated browser contexts for repeatable runs.
• QA engineers validating real Firefox behavior for login, checkout, and multi-step forms where DOM-only clicks are not enough.

Not ideal for:

• Teams that need one abstraction across Chromium, WebKit, and Firefox with identical behavior.
• Projects that only need simple scraping and do not care about session fidelity or event provenance.
• Org setups that cannot manage Firefox binaries, profile directories, and environment-specific launch parameters.

Key Features of ruyiPage

• BiDi-first architecture — ruyiPage is built on Firefox + WebDriver BiDi, not CDP. That matters because the protocol surface is aligned with Firefox internals, which is the point of the project.
• Native action emphasis — The README highlights many isTrusted native actions, which is the right direction for sites that inspect synthetic input. In practice, this means clicks, typing, and drag flows are designed to look like browser-generated events instead of DOM shortcuts.
• Request and response interception — ruyiPage can intercept arbitrary network packets for AI analysis and data capture. That makes it useful for collectors, traffic inspection, and mocks where you need visibility into what the browser actually saw.
• Existing browser attachment — auto_attach_exist_browser_by_process() can hook into a Firefox instance that is already open, including fingerprint browsers such as ADS or FlowerBrowser. This is a strong fit when you need to take over a session without relaunching it.
• XPath picker and code generation — The built-in XPath Picker shows element metadata, absolute and relative XPath, center coordinates, and even generated ruyiPage code. It also handles iframe, nested iframe, and open shadow root chains, which saves time on brittle selector debugging.
• Session and context isolation — user_dir support lets you keep cookies, local storage, extensions, and certs across runs, while temporary profiles give you one-off sessions. The README also calls out multi-tab usage with different user contexts, which is the kind of separation automation teams usually end up building by hand.
• Operational extras — ruyiPage covers downloads, screenshots, PDF export, prompts, actions, touch events, and navigation events in the same API surface. That reduces the number of helper libraries you need around the browser core.

ruyiPage vs Alternatives

Pick Playwright when your team needs one API for multiple engines and you care more about cross-browser parity than Firefox-specific behavior. Pick Selenium 4 when your organization already has WebDriver infrastructure, test grids, and a long-lived automation estate.

Pick ruyiPage when Firefox behavior is the product requirement, not a detail. If your workflow also needs packet-level visibility after the browser session starts, pair it with OpenTrace; if the browser run is one step in a larger agent pipeline, OpenSwarm is a better orchestration layer above the page API.

How ruyiPage Works

ruyiPage wraps a Firefox browser instance around a Python page object model and exposes a small set of high-value primitives: FirefoxOptions, FirefoxPage, launch(), page.actions, page.network, page.events, and page.contexts. The architectural bet is simple: keep the browser protocol close to WebDriver BiDi, keep the API Pythonic, and preserve the semantics of real user activity wherever possible.

That design shows up in the features that matter for hostile sites. The framework prefers browser-native actions, supports private mode and user directories, and can attach to an already running Firefox process by inspecting process characteristics instead of requiring a clean launch every time. For teams doing capture work, that means fewer resets, less profile churn, and a better shot at preserving session state.

from ruyipage import launch

page = launch(
    browser_path='/usr/bin/firefox',
    user_dir='/tmp/ruyipage',
    headless=False,
    port=9222,
)

page.get('https://www.example.com')
print(page.title)
page.quit()

The snippet launches Firefox with a persistent profile directory, opens a page, reads the title, and shuts down cleanly. In a real workflow, the next step is usually element lookup with page.ele(), then either native input, interception, or context-specific navigation depending on the target site.

If you need to inspect what the browser is doing while the page is active, the event and network layers are the interesting part of ruyiPage. That is where you would connect debugging, logging, or a companion tracer such as OpenTrace so request behavior and browser state stay aligned during a run.

Pros and Cons of ruyiPage

Pros:

• Firefox-first stack with WebDriver BiDi instead of CDP, which matches the browser family it is built for.
• Native action focus improves the odds of passing isTrusted checks on sites that inspect event provenance.
• Network interception, mock, fail, and collector patterns are built into the workflow rather than bolted on.
• Existing-session attachment is useful for fingerprint browsers and manual-to-automated handoff.
• XPath Picker reduces selector guesswork in iframe and shadow DOM heavy pages.
• Private mode, user directories, downloads, PDFs, screenshots, and prompt handling are all exposed in one library.

Cons:

• Firefox-only focus means it is not the right abstraction for teams that need identical behavior across all major engines.
• The documentation and ecosystem are smaller than Playwright or Selenium, so you will write more of your own integration glue.
• High-risk site success still depends on target-side rules, browser version, profile hygiene, and network conditions.
• Managing browser_path, user_dir, and sometimes a debug port adds operational overhead compared with a fully managed cloud runner.
• The repo text does not expose numeric star or download counts, so external popularity signals are harder to evaluate from the README alone.

Getting Started with ruyiPage

The fastest path is to install the package, verify the import, and run a short launch script against a harmless page. That gives you a working Firefox session and confirms that your local binary, Python environment, and profile permissions are all sane.

pip install ruyiPage --upgrade
python - <<'PY'
from ruyipage import launch

page = launch(headless=False)
page.get('https://www.example.com')
print(page.title)
page.quit()
PY

If you need a persistent identity, add browser_path and user_dir through FirefoxOptions or launch(). If you only need a disposable session, skip user_dir and let ruyiPage create a temporary profile that is cleared when the process exits.

Verdict

ruyiPage is the strongest option for Firefox-first, high-friction automation when you need BiDi control and isTrusted-style input rather than generic cross-browser abstraction. Its best strength is native event fidelity; its main caveat is Firefox-specific setup and a smaller ecosystem. Recommended for teams that care more about realistic sessions than browser breadth.