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

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 lines 33-38
tumblr	API returns status: 429 with "Limit Exceeded" message	holehe/modules/social_media/tumblr.py lines 91-92
vivino	HTTP 429 status code from Vivino endpoint	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, 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, the module checks the response status code directly:

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 uses broader exception handling to catch throttling scenarios:

# 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:

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:

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 interprets the rateLimit flag to format console output. When rateLimit is True, the result appears with a yellow [x] indicator:

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	Demonstrates token-based failure detection and "url" key block detection
holehe/modules/social_media/tumblr.py	Shows explicit HTTP 429 status checking with API message parsing
holehe/modules/shopping/vivino.py	Simple 429 status code handling pattern
holehe/core.py	print_result function renders rate-limited results with yellow [x] markers
holehe/modules/programming/lastpass.py	Generic exception handling pattern for request failures
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 (around line 22) checks results["rateLimit"] and renders affected domains with yellow color coding via print_color("[x] " + results["domain"], "yellow", args).

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}