# What Causes Rate Limiting in Holehe Modules and How the `rateLimit` Field Gets Set

> Discover what causes rate limiting in holehe modules and how the rateLimit field is set. Learn to identify and manage these limitations effectively.

- Repository: [Palenath/holehe](https://github.com/megadose/holehe)
- Tags: internals
- Published: 2026-08-15

---

**Rate limiting in holehe occurs when target services return HTTP 429 status codes, redirect to temporary block pages, or when modules fail to acquire required authentication tokens, triggering the `rateLimit` flag to be set to `True` in the result dictionary.**

Holehe is an open-source OSINT tool that checks for account existence across hundreds of online services. Each service check runs in a dedicated module that performs HTTP requests—typically using `httpx` with `trio` for async concurrency. When a service detects excessive requests, it responds with throttling indicators that holehe modules capture and report through the `rateLimit` field.

## Common Triggers for Rate Limiting in Holehe Modules

Modules detect rate limiting through several distinct patterns in server responses. The specific condition varies by service implementation.

| Module | Rate Limit Trigger | Source Location |
|--------|-------------------|-----------------|
| **blablacar** | Failed `appToken` acquisition, request header exceptions, or JSON response containing `"url"` key (temporary block) | [`holehe/modules/transport/blablacar.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/transport/blablacar.py) lines 33-38 |
| **tumblr** | API returns `status: 429` with "Limit Exceeded" message | [`holehe/modules/social_media/tumblr.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/social_media/tumblr.py) lines 91-92 |
| **vivino** | HTTP 429 status code from Vivino endpoint | [`holehe/modules/shopping/vivino.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/shopping/vivino.py) lines 29-30 |
| **Generic pattern** | Any exception during request execution (missing tokens, connection errors) | `except Exception` blocks in modules like [`lastpass.py`](https://github.com/megadose/holehe/blob/main/lastpass.py), [`office365.py`](https://github.com/megadose/holehe/blob/main/office365.py) |

## How Modules Set the `rateLimit` Field to `True`

The `rateLimit` field is a boolean flag in the standardized result dictionary that each module appends to the shared `out` list. When throttling is detected, modules explicitly set `"rateLimit": True`.

### Example from Tumblr: Explicit HTTP 429 Detection

In [`holehe/modules/social_media/tumblr.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/social_media/tumblr.py), the module checks the response status code directly:

```python
if response.status_code == 429:
    out.append({
        "name": name,
        "domain": domain,
        "method": method,
        "frequent_rate_limit": frequent_rate_limit,
        "rateLimit": True,          # rate-limit hit

        "exists": False,
        "emailrecovery": None,
        "phoneNumber": None,
        "others": None
    })

```

This pattern detects when Tumblr's API explicitly signals throttling through standard HTTP semantics.

### Example from Blablacar: Token Failure and Block Detection

The blablacar module in [`holehe/modules/transport/blablacar.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/transport/blablacar.py) uses broader exception handling to catch throttling scenarios:

```python

# Token acquisition or request building failed

except Exception:
    out.append({
        "name": name,
        "domain": domain,
        "method": method,
        "frequent_rate_limit": frequent_rate_limit,
        "rateLimit": True,          # throttling detected

        "exists": False,
        "emailrecovery": None,
        "phoneNumber": None,
        "others": None
    })
    return None

```

Additionally, this module checks for a `"url"` key in successful JSON responses, which indicates a temporary redirect to a block page rather than normal API data.

### Example from Vivino: Direct Status Code Check

The vivino module demonstrates the minimal detection pattern in [`holehe/modules/shopping/vivino.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/shopping/vivino.py):

```python
if response.status_code == 429:
    out.append({
        "name": name,
        "domain": domain,
        "method": method,
        "frequent_rate_limit": frequent_rate_limit,
        "rateLimit": True,
        "exists": False,
        "emailrecovery": None,
        "phoneNumber": None,
        "others": None
    })

```

## The `frequent_rate_limit` Module Flag vs. Runtime `rateLimit`

Each module defines a static `frequent_rate_limit` boolean at the top of the file:

```python
frequent_rate_limit = True  # or False

```

This flag is **informational only**—it warns users that a service is known for strict throttling (e.g., Blablacar sets `frequent_rate_limit = True`). The actual `rateLimit` field is set **dynamically at runtime** based on whether the current request encountered throttling.

## How Holehe Displays Rate-Limited Results

The `print_result` function in [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py) interprets the `rateLimit` flag to format console output. When `rateLimit` is `True`, the result appears with a yellow `[x]` indicator:

```python
if results["rateLimit"] and args.onlyused == False:
    websiteprint = print_color("[x] " + results["domain"], "yellow", args)

```

This visual distinction helps users identify which services couldn't be checked due to throttling versus those where no account was found (marked differently) or where an account exists.

## Key Implementation Files

| File | Role in Rate Limiting |
|------|----------------------|
| [`holehe/modules/transport/blablacar.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/transport/blablacar.py) | Demonstrates token-based failure detection and "url" key block detection |
| [`holehe/modules/social_media/tumblr.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/social_media/tumblr.py) | Shows explicit HTTP 429 status checking with API message parsing |
| [`holehe/modules/shopping/vivino.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/shopping/vivino.py) | Simple 429 status code handling pattern |
| [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py) | `print_result` function renders rate-limited results with yellow `[x]` markers |
| [`holehe/modules/programming/lastpass.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/programming/lastpass.py) | Generic exception handling pattern for request failures |
| [`holehe/modules/office365/office365.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/office365/office365.py) | Similar exception-based `rateLimit=True` assignment |

## Summary

- **HTTP 429 status codes** are the primary trigger for rate limiting detection across holehe modules
- **Authentication token failures** and **connection exceptions** also set `rateLimit=True` when they prevent normal request completion
- The **`rateLimit` field** is set dynamically in each module's result dictionary when throttling is detected at runtime
- **`frequent_rate_limit`** is a static module property indicating known-strict services, not a runtime detection mechanism
- Results with `rateLimit=True` display as **yellow `[x]`** in holehe's console output via `holehe.core.print_result`

## Frequently Asked Questions

### What does HTTP 429 mean in holehe results?

HTTP 429 is the "Too Many Requests" status code. When a service returns this status, the holehe module detects throttling and sets `rateLimit=True` to indicate the check couldn't complete normally. This appears as a yellow `[x]` in output rather than a definitive account-existence result.

### How is rate limiting different from a service being down?

Rate limiting (`rateLimit=True`) specifically indicates the service actively blocked the request due to request volume. Complete service unavailability typically triggers different error paths—though both may result in `exists=False`, the `rateLimit` flag preserves the distinction for accurate interpretation.

### Can I avoid rate limits when using holehe?

The `frequent_rate_limit` module flags identify services with strict throttling, but no built-in rate limit avoidance exists in holehe core. Users should space requests appropriately, rotate egress IPs, or reduce concurrency when checking services marked with `frequent_rate_limit=True`.

### Where does holehe print the rate limit status?

The `print_result` function in [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py) (around line 22) checks `results["rateLimit"]` and renders affected domains with yellow color coding via `print_color("[x] " + results["domain"], "yellow", args)`.