# What Does the `frequent_rate_limit` Flag Indicate in Holehe Modules?

> Understand the frequent_rate_limit flag in Holehe modules. Learn how this Boolean attribute helps adjust request strategies for services with strict rate limits.

- Repository: [Palenath/holehe](https://github.com/megadose/holehe)
- Tags: deep-dive
- Published: 2026-08-17

---

**The `frequent_rate_limit` flag is a Boolean metadata attribute that signals whether a target service enforces strict or rapidly-triggered rate-limit policies, allowing Holehe's core scanner to adjust request strategies and back-off delays accordingly.**

The `frequent_rate_limit` flag plays a critical role in the megadose/holehe repository's email intelligence framework. Defined within individual OSINT modules, this Boolean value communicates the throttling behavior of specific services to the central orchestration engine in [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py). Understanding this flag helps developers interpret scan reliability and optimize query patterns when checking email existence across multiple platforms.

## Understanding the `frequent_rate_limit` Metadata Flag

Each Holehe module (located in `holehe/modules/`) defines `frequent_rate_limit` as a constant Boolean variable at the module level. This flag is **not** a request-time configuration but static metadata that each module supplies to the central scanning engine. It indicates whether the target service applies *very strict* or *rapidly-triggered* rate-limit policies—such as frequent HTTP 429 responses—when the API is queried.

Modules that set the flag to `True` are considered high-risk for throttling, while modules setting it to `False` are treated as having normal rate-limit behavior and can be queried more aggressively.

## How the Core Scanner Processes the Flag

In [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py), the orchestration code reads the `frequent_rate_limit` value from each module's result dictionary to adapt its request strategy. When this flag is set to `True`, the engine implements three specific protective measures:

1.  **Skip Further Requests** – After the first detection of a limit, the scanner marks `"rateLimit": True` in the output and may abort additional queries to that service during the current run.

2.  **Apply Extended Back-Off** – The engine inserts a longer delay (asynchronous sleep) before retrying the same service, preventing account lockouts or IP bans.

3.  **Inform the User** – The output metadata explicitly flags the service as prone to throttling, warning that results may be less reliable when many accounts are checked in quick succession.

## Module Implementation Examples

### High-Risk Services: Blablacar and Patreon

Services with aggressive throttling set `frequent_rate_limit=True`. In [`holehe/modules/transport/blablacar.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/transport/blablacar.py) and [`holehe/modules/social_media/patreon.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/social_media/patreon.py), the modules define this flag and include it in the returned dictionary:

```python

# Simplified structure from blablacar.py / patreon.py

out.append({
    "name": name,
    "domain": domain,
    "method": method,
    "frequent_rate_limit": frequent_rate_limit,   # Boolean: True

    "rateLimit": False,                           # Set later by core if throttled

    "exists": data["exists"],
    "emailrecovery": None,
    "phoneNumber": None,
    "others": None,
})

```

### Standard Services: Bodybuilding

Conversely, services with normal rate limits set the flag to `False`. In [`holehe/modules/sport/bodybuilding.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/sport/bodybuilding.py), the module indicates that the service can handle standard query frequencies without triggering aggressive throttling.

## Practical Impact on Scanning Behavior

When you run Holehe from the command line, the `frequent_rate_limit` metadata appears in the JSON output, providing transparency about service reliability:

```bash
$ holehe -u user@example.com

```

The resulting JSON entry for a rate-limited service appears as:

```json
{
  "name": "blablacar",
  "domain": "blablacar.com",
  "method": "register",
  "frequent_rate_limit": true,
  "rateLimit": true,
  "exists": false,
  "emailrecovery": null,
  "phoneNumber": null,
  "others": null
}

```

The `"frequent_rate_limit": true` entry explains why `"rateLimit": true` appears in the output—indicating that the scanner encountered throttling due to the service's strict policies.

## Summary

- The `frequent_rate_limit` flag is a **Boolean metadata attribute** defined in individual Holehe modules (e.g., [`blablacar.py`](https://github.com/megadose/holehe/blob/main/blablacar.py), [`bodybuilding.py`](https://github.com/megadose/holehe/blob/main/bodybuilding.py)).
- It signals whether a service enforces **strict or rapidly-triggered rate limiting** (HTTP 429 responses).
- [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py) uses this flag to determine **back-off strategies**, potentially skipping requests or adding delays for flagged services.
- Modules with `frequent_rate_limit=False` are queried more aggressively, while `True` values trigger cautious scanning behavior.

## Frequently Asked Questions

### What happens when a module sets `frequent_rate_limit` to `True`?

When a module sets `frequent_rate_limit=True`, Holehe's core scanner treats the service as high-risk for throttling. According to [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py), this triggers longer back-off delays between requests and may cause the engine to skip further queries after detecting a single rate-limit response to preserve scan integrity.

### Can I override the `frequent_rate_limit` setting?

No, the `frequent_rate_limit` flag is hardcoded metadata within each module (such as [`patreon.py`](https://github.com/megadose/holehe/blob/main/patreon.py) or [`bodybuilding.py`](https://github.com/megadose/holehe/blob/main/bodybuilding.py)) and is not exposed as a user-configurable parameter. It represents the module author's assessment of the service's anti-automation policies based on empirical testing.

### How does `frequent_rate_limit` differ from `rateLimit` in the output?

The `frequent_rate_limit` field is **predictive metadata** set by the module indicating the service's general throttling propensity. The `rateLimit` field is **runtime status** set by [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py) during execution when the scanner actually encounters an HTTP 429 or similar throttling response. A service can have `frequent_rate_limit=true` while showing `rateLimit=false` if the current scan avoided triggering the limit.

### Which services in Holehe are marked as frequently rate-limited?

According to the source code analysis, services like **Blablacar** ([`holehe/modules/transport/blablacar.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/transport/blablacar.py)) and **Patreon** ([`holehe/modules/social_media/patreon.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/social_media/patreon.py)) set `frequent_rate_limit=True`. In contrast, services like **Bodybuilding** ([`holehe/modules/sport/bodybuilding.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/sport/bodybuilding.py)) set the flag to `False`, indicating they tolerate standard query volumes without aggressive throttling.