rookie

Rookie supports a wide range of browsers across Windows, Linux, and macOS.

Supported Browsers:

• Arc (Linux, macOS, Windows)
• Brave (Linux, macOS, Windows)
• Cachy (Linux)
• Chrome (Linux, macOS, Windows)
• Chromium (Linux, macOS, Windows)
• Edge (Linux, macOS, Windows)
• Firefox (Linux, macOS, Windows)
• Internet Explorer (Windows)
• LibreWolf (Linux, macOS, Windows)
• Opera (Linux, macOS, Windows)
• Opera GX (macOS, Windows)
• Safari (macOS)
• Vivaldi (Linux, macOS, Windows)
• Zen (Linux, macOS)

When using rookie, be aware of the following behaviors:

• Password Prompts: On Linux or macOS with Chromium-based browsers, accessing cookies may trigger a password prompt from kde-wallet.
• Session Cookies in Chrome-based browsers: Due to security features preventing external access to the cookies file, rookie may seamlessly restart the browser to bypass this. This allows session cookies to be retrieved, but they will expire once the browser is closed again.

If you are running on an unsupported platform like Android, you can still use rookie by manually locating and providing the path to the browser's Cookies file.

1. Find the Cookies file on the device (e.g., using find /data/data -type f -name Cookies).
2. Pull the file to your environment.
3. Execute the rookie-cli by passing the path to that file using the --path flag.

./cli --path <Cookies path>

Node.js bindings are built using @napi-rs/cli. Ensure you have bun installed to install the CLI globally, then run napi build within the bindings/python directory (Note: the documentation points to the bindings/python directory for Node bindings; verify path if this is a typo in the source).

bun install -g @napi-rs/cli
cd bindings/python
napi build

Install the Python bindings using pip install rookiepy. The usage pattern involves calling browser functions (e.g., firefox) with a list of domains to retrieve cookie data as a list of dictionaries.

pip install rookiepy

import rookiepy
cookies = rookiepy.firefox(["google.com"])
for cookie in cookies:
    print(cookie['domain'], cookie['value'])

Install the rookiepy package using pip3. It is recommended to use the -U flag to ensure you are using the latest version.

pip3 install -U rookiepy

Logging for rookiepy is controlled via the standard Python logging module.

To enable detailed debugging, set the root logger level to logging.DEBUG. To suppress all rookiepy logs, set the level to logging.CRITICAL.

import logging

# Enable debug logging
logging.basicConfig()
logging.getLogger().setLevel(logging.DEBUG)

# Disable all rookiepy logging
logging.getLogger().setLevel(logging.CRITICAL)

The @rookie-rs/api package provides Node.js bindings for the rookie library, allowing you to programmatically extract cookies from installed web browsers. You can use the chrome() function (or other browser-specific exports) to retrieve a collection of cookies.

import { chrome } from "@rookie-rs/api";

const cookies = chrome();
for (const cookie of cookies) {
  console.log(cookie);
}

To use rookie in a Rust project, add it via cargo. You can then call browser-specific functions (like brave) to retrieve cookies. You can optionally pass a vector of domain strings to filter the results.

cargo add rookie

use rookie::brave;

fn main() {
    let domains = vec!["google.com"];
    let cookies = brave(Some(domains)).unwrap();
    for cookie in cookies {
        println!("{:?}", cookie);
    }
}