# How Agent Reach Extracts Cookies from Browsers: Implementation and Supported Platforms

> Learn how Agent Reach extracts browser cookies like authentication tokens from Chrome Firefox Edge Brave Opera using rookiepy or browser_cookie3 for automated social channel setup.

- Repository: [Pnant/Agent-Reach](https://github.com/Panniantong/Agent-Reach)
- Tags: how-to-guide
- Published: 2026-07-05

---

**Agent Reach extracts authentication tokens from Chrome, Firefox, Edge, Brave, and Opera using either the Rust-based `rookiepy` library or the pure-Python `browser_cookie3` fallback, filters them against domain-specific platform specifications, and writes the results to `~/.agent_reach.yaml` for automated social media channel configuration.**

Agent Reach is an open-source automation framework that authenticates with social media platforms using cookies from your local browser sessions. Understanding how it extracts and processes these cookies is essential for troubleshooting authentication issues and extending support to new platforms.

## The Dual-Backend Extraction Engine

The cookie extraction logic resides in [`agent_reach/cookie_extract.py`](https://github.com/Panniantong/Agent-Reach/blob/main/agent_reach/cookie_extract.py) and implements a priority-based backend selection strategy. The system prefers **rookiepy**—a Rust-based extractor known for faster performance and better reliability—falling back to **browser_cookie3** only when necessary.

At runtime, the `extract_all()` function attempts to import the preferred library:

```python
try:
    import rookiepy          # preferred backend

    use_rookiepy = True
except ImportError:
    import browser_cookie3   # fallback

    use_rookiepy = False

```

This import pattern occurs inside `extract_all()` (lines 55-63), ensuring that missing dependencies do not crash the application. When `rookiepy` is available, the system uses browser-specific functions like `rookiepy.chrome()` or `rookiepy.firefox()`. Otherwise, it calls equivalent methods from `browser_cookie3`.

## Platform-Specific Cookie Specifications

Agent Reach does not extract arbitrary cookies. Instead, it matches cookies against a static `PLATFORM_SPECS` list (defined at lines 15-41 in [`cookie_extract.py`](https://github.com/Panniantong/Agent-Reach/blob/main/cookie_extract.py)) that defines exactly which domains and cookie names are required for each service:

```python
PLATFORM_SPECS = [
    {"name": "Twitter/X", "domains": [".x.com", ".twitter.com"],
     "cookies": ["auth_token", "ct0"], "config_key": "twitter"},
    {"name": "XiaoHongShu", "domains": [".xiaohongshu.com"],
     "cookies": None, "config_key": "xhs"},
    {"name": "Bilibili", "domains": [".bilibili.com"],
     "cookies": ["SESSDATA", "bili_jct"], "config_key": "bilibili"},
    # ... additional platforms

]

```

Each specification contains:

- **domains**: List of domain suffixes to match against cookie domains
- **cookies**: Either a list of specific cookie names to extract, or `None` to serialize all matching cookies as a header string
- **config_key**: The key used when writing results to the configuration file

For Twitter/X, the system specifically hunts for `auth_token` and `ct0` cookies. For XiaoHongShu, it captures the entire cookie jar as a formatted string because the platform requires multiple dynamic tokens.

## From Browser Database to Configuration File

The `extract_all(browser: str)` function orchestrates the full extraction pipeline. It accepts browser names (`chrome`, `firefox`, `edge`, `brave`, or `opera`) and returns a dictionary keyed by platform configuration keys.

The extraction flow follows these steps:

1. **Select backend** based on availability (lines 78-88)
2. **Query browser store** using `rookiepy.chrome()` or `browser_cookie3.chrome()` (lines 101-109)
3. **Filter by domain** - iterates through the raw cookie jar and keeps only cookies where `domain` ends with a specified pattern
4. **Extract or serialize** - either pulls specific named cookies or formats all cookies as `name=value; name2=value2` strings (lines 118-148)

The resulting structure looks like:

```json
{
    "twitter": {"auth_token": "abc123...", "ct0": "xyz789..."},
    "xhs": {"cookie_string": "sessionid=def456; ..."},
    "bilibili": {"SESSDATA": "ghi789...", "bili_jct": "jkl012..."}
}

```

The `configure_from_browser()` function (lines 225-290) then writes these values into the central `Config` object ([`agent_reach/config.py`](https://github.com/Panniantong/Agent-Reach/blob/main/agent_reach/config.py)), persisting them to `~/.agent_reach.yaml`. It also performs legacy syncs to the **xfetch** session file and writes a `credentials.env` file for the optional **bird** CLI.

## Programmatic and CLI Usage

You can trigger cookie extraction programmatically or via command line:

**Python API:**

```python
from agent_reach.cookie_extract import extract_all, configure_from_browser
from agent_reach.config import Config

cfg = Config()
cookies = extract_all("chrome")
print(cookies)  # Dictionary of platform tokens

results = configure_from_browser("chrome", cfg)
for platform, ok, msg in results:
    print(f"{platform}: {'✅' if ok else '❌'} {msg}")

```

**Command Line:**

```bash

# Auto-import during installation (tries Chrome, then Firefox)

agent-reach install --channels=twitter,xiaohongshu

# Manual browser selection

agent-reach configure --from-browser chrome

```

The CLI implementation in [`agent_reach/cli.py`](https://github.com/Panniantong/Agent-Reach/blob/main/agent_reach/cli.py) (lines 71-88) attempts Chrome first, then falls back to Firefox if no cookies are found, displaying status messages like "✅ Twitter/X: auth_token + ct0".

## Summary

- **Agent Reach** extracts cookies in [`agent_reach/cookie_extract.py`](https://github.com/Panniantong/Agent-Reach/blob/main/agent_reach/cookie_extract.py) using a priority system that prefers `rookiepy` over `browser_cookie3`.
- Supported browsers include **Chrome, Firefox, Edge, Brave, and Opera**, selected by passing the browser name to `extract_all()`.
- The **PLATFORM_SPECS** dictionary defines exactly which cookies to extract for each social media platform, filtering by domain and specific cookie names.
- Extracted tokens are written to **`~/.agent_reach.yaml`** via `configure_from_browser()`, with additional syncs to legacy session files.

## Frequently Asked Questions

### Which browsers does Agent Reach support for cookie extraction?

Agent Reach supports **Chrome, Firefox, Edge, Brave, and Opera**. The `extract_all()` function in [`agent_reach/cookie_extract.py`](https://github.com/Panniantong/Agent-Reach/blob/main/agent_reach/cookie_extract.py) accepts these browser names as string arguments and maps them to the appropriate backend functions in either `rookiepy` or `browser_cookie3`.

### What specific cookies does Agent Reach extract for Twitter/X?

For Twitter/X, Agent Reach specifically extracts **`auth_token`** and **`ct0`** cookies from domains ending in `.x.com` or `.twitter.com`. These are defined in the `PLATFORM_SPECS` list at lines 15-41 of [`cookie_extract.py`](https://github.com/Panniantong/Agent-Reach/blob/main/cookie_extract.py), where the `cookies` key lists the required authentication tokens.

### How does Agent Reach handle cookie extraction when rookiepy is not installed?

If `rookiepy` is not available, Agent Reach automatically falls back to **`browser_cookie3`**, a pure-Python library. The code wraps the import in a try-except block (lines 55-63) and sets a boolean flag that determines which backend functions to call during the extraction phase.

### Where does Agent Reach store extracted cookies after extraction?

Extracted cookies are persisted to **`~/.agent_reach.yaml`** through the `Config` class in [`agent_reach/config.py`](https://github.com/Panniantong/Agent-Reach/blob/main/agent_reach/config.py). The `configure_from_browser()` function also creates ancillary files including a legacy **xfetch** session file and an optional `credentials.env` for the **bird** CLI tool.