# Does Holehe Have Built‑In Retry Logic for Rate Limits?

> Discover if Holehe handles rate limit retries. Learn how Holehe flags rate limits but lacks automatic retry logic for smoother API interactions.

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

---

**Holehe detects HTTP 429 rate‑limit responses and reports them via the `[x] Rate limit` status flag, but the library does not implement automatic retries, exponential back‑off, or any retry loop.**

When auditing email addresses across hundreds of platforms, encountering API rate limits is inevitable. If you are using the open‑source OSINT tool **Holehe** (megadose/holehe) for account discovery, understanding its **rate limit retry logic** is critical for reliable data collection. While the tool explicitly identifies when a service throttles requests, it moves on immediately rather than waiting.

## How Holehe Detects Rate Limits

Holehe’s core module explicitly watches for HTTP 429 responses and surfaces them to the user through a standardized status reporting system. In [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py), the application builds a color‑coded status line that includes a specific flag for rate‑limited services, allowing operators to see which platforms blocked the request.

The status output is constructed using the `print_color` helper, concatenating result states for each checked service:

```python

# In holehe/core.py – Status line construction

description = (
    print_color("[+] Email used", "green", args) + ","
    + print_color(" [-] Email not used", "magenta", args) + ","
    + print_color(" [x] Rate limit", "yellow", args) + ","
    + print_color(" [!] Error", "red", args)
)

```

When a module returns a rate‑limited status, the `[x] Rate limit` flag appears in the CLI output, clearly indicating that the target service enforced throttling.

## Module‑Level Rate Limit Checks

Individual service modules follow a consistent pattern: they detect **429 status codes** but immediately return without retrying. This design appears across multiple modules in the repository, confirming that **Holehe rate limit handling** is strictly for reporting, not recovery.

In [`holehe/modules/shopping/vivino.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/shopping/vivino.py), the code checks the response status and returns a specific dictionary indicating the limitation:

```python

# In holehe/modules/shopping/vivino.py – Detection without retry

if response.status_code == 429:
    # Mark as rate-limited; function returns without retrying

    return {"status": "rate_limited"}

```

A similar implementation exists in [`holehe/modules/social_media/tumblr.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/social_media/tumblr.py), where the module again checks for `response.status_code == 429` and returns immediately. In both cases, **no exponential back‑off**, sleep interval, or retry loop follows the detection.

## Why Automatic Retries Are Not Implemented

This behavior is architectural. Holehe prioritizes speed and breadth over depth; when a service throttles requests, the tool marks the result and continues to the next platform rather than blocking the entire scanning process.waiting for rate limit windows to reset would significantly slow down bulk email audits spanning hundreds of sites. Consequently, the **megadose/holehe** codebase treats rate limits as terminal states for that specific service check.

## Implementing External Retry Logic

Since Holehe lacks built‑in retry mechanisms, users requiring resilient checks must implement their own wrappers. You have several options for handling `[x] Rate limit` responses programmatically:

- **Tenacity or Backoff Libraries**: Wrap Holehe module calls with Python’s `tenacity` or `backoff` decorators to catch rate‑limited responses and retry after a calculated delay.
- **Manual Re‑queuing**: Parse the JSON output for `"status": "rate_limited"` and re‑queue the email‑platform pair in your own task scheduler after an appropriate cool‑down period.
- **Proxy Rotation**: Since Holehe does not retry, implementing proxy rotation at the network layer can bypass rate limits before they trigger, avoiding the need for retry logic entirely.

## Summary

- **Holehe detects rate limits** via HTTP 429 checks in individual modules and reports them using the `[x] Rate limit` flag in [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py).
- **No automatic retry logic** exists; modules such as [`vivino.py`](https://github.com/megadose/holehe/blob/main/vivino.py) and [`tumblr.py`](https://github.com/megadose/holehe/blob/main/tumblr.py) return immediately upon detecting a 429 status.
- **Status reporting** uses color‑coded output to distinguish between successful checks, negative results, rate limits, and errors.
- **External implementation required**: Users must build their own retry loops or queuing systems if they need to re‑attempt throttled requests.

## Frequently Asked Questions

### Does Holehe automatically retry when it hits a rate limit?

No, Holehe does not automatically retry requests. When a module detects an HTTP 429 response, it returns a `{"status": "rate_limited"}` dictionary and moves to the next service. There is no exponential back‑off or retry loop implemented in the current `megadose/holehe` codebase.

### How does Holehe indicate that a rate limit was reached?

Holehe uses the `[x] Rate limit` flag in its CLI output, rendered in yellow via the `print_color` function in [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py). This visual indicator appears alongside `[+] Email used`, `[-] Email not used`, and `[!] Error` flags to provide immediate status feedback.

### Can I add retry logic to Holehe myself?

Yes. Because Holehe returns structured status dictionaries (including `"status": "rate_limited"`), you can wrap calls to the library in your own Python code using libraries like `tenacity` or `backoff`. Check the return value for the rate‑limited status, then implement your own sleep interval and retry counter before re‑invoking the check.

### Which Holehe modules check for HTTP 429 status codes?

Multiple modules implement explicit 429 checks, including [`holehe/modules/shopping/vivino.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/shopping/vivino.py) and [`holehe/modules/social_media/tumblr.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/social_media/tumblr.py). These files demonstrate the library’s standard pattern of detecting rate limits without implementing retry behavior, confirming that users must handle throttling externally.