# What Information Is Returned in the Holehe Module Results Dictionary?

> Discover the standardized dictionary returned by Holehe modules. Learn about keys like exists, rateLimit, error, emailrecovery, and phoneNumber to understand email registration and recovery details.

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

---

**Each Holehe module returns a standardized dictionary containing ten specific keys—including `exists`, `rateLimit`, `error`, `emailrecovery`, and `phoneNumber`—that describe whether an email is registered, if rate limits were hit, and what recovery information is available.**

Holehe is an open-source email OSINT tool maintained by megadose that checks if an email address is registered across hundreds of websites. When you run a check programmatically or via CLI, every module appends a results dictionary to a shared output list. Understanding the structure of this Holehe module results dictionary is essential for parsing outcomes, handling errors, and extracting recovery metadata like secondary emails or phone numbers.

## Anatomy of the Holehe Results Dictionary

The dictionary follows a strict schema defined in [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py) and implemented across individual modules. Each result contains exactly ten keys:

- **`name`**: The internal module identifier (e.g., `"instagram"` or `"adobe"`).

- **`domain`**: The target website's domain (e.g., `"instagram.com"`).

- **`method`**: The detection technique employed, typically `"register"` or `"password recovery"`. Some modules omit this field depending on the check type.

- **`frequent_rate_limit`**: Boolean flag indicating whether the service is known for aggressively throttling frequent requests. Set explicitly by individual modules.

- **`rateLimit`**: `True` if the request encountered a rate limit or network issue that prevented completion; `False` otherwise. This is set by the orchestration logic in `launch_module`.

- **`error`**: `True` when an unexpected exception occurred during the request; `False` otherwise. Also managed by `launch_module` in [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py).

- **`exists`**: Boolean indicating registration status. `True` means the email is already registered on the service; `False` means it is not available or not registered.

- **`emailrecovery`**: Contains the secondary email address returned by password recovery endpoints when available; otherwise `None`. Populated in modules like [`adobe.py`](https://github.com/megadose/holehe/blob/main/adobe.py).

- **`phoneNumber`**: Stores the recovery phone number returned by the service, or `None` if not exposed or not supported.

- **`others`**: A flexible dictionary for additional metadata such as full names or creation dates. Most modules set this to `None` when no extra data is retrieved.

## How [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py) Assembles Results

The `launch_module` function in [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py) orchestrates the execution of each checker. The dictionary construction follows two distinct paths:

### Normal Execution Flow

When a module executes successfully, it manually constructs and appends the dictionary to the shared `out` list. For example, [`holehe/modules/social_media/instagram.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/social_media/instagram.py) populates `frequent_rate_limit` and `method` alongside the standard keys, while [`holehe/modules/software/adobe.py`](https://github.com/megadose/holehe/blob/main/holehe/modules/software/adobe.py) demonstrates populating `emailrecovery` and `phoneNumber` from JSON responses.

### Exception Fallback Handling

If a module raises an uncaught exception, `launch_module` catches it at lines 66-78 and appends a fallback dictionary with `rateLimit=True` and `error=True`, ensuring the output list maintains consistent structure even when services fail.

## Parsing Holehe Results Programmatically

When integrating Holehe into Python workflows, you interact with the results dictionary directly before the CLI formatting occurs. Here is how to capture and inspect the raw data:

```python
import asyncio
import httpx
from holehe.modules.social_media import instagram
from holehe.modules.software import adobe

async def check_email(email: str):
    async with httpx.AsyncClient(timeout=10) as client:
        results = []
        
        # Each module appends its dictionary to the results list

        await instagram.instagram(email, client, results)
        await adobe.adobe(email, client, results)
        
        for result in results:
            print(f"Domain: {result['domain']}")
            print(f"  Registered: {result['exists']}")
            print(f"  Rate Limited: {result['rateLimit']}")
            print(f"  Error: {result['error']}")
            print(f"  Recovery Email: {result['emailrecovery']}")
            print(f"  Phone: {result['phoneNumber']}")
            print(f"  Extra Data: {result['others']}")
            print()

# Run the check

asyncio.run(check_email("target@example.com"))

```

The CLI output you see when running `holehe target@example.com` is simply a formatted representation of these dictionaries, where `[+]` indicates `exists=True`, `[-]` indicates `exists=False`, and `[!]` indicates `error=True`.

## Summary

- The Holehe module results dictionary contains **ten standardized keys** that describe registration status, rate limiting, errors, and recovery information.
- **Critical keys** include `exists` (registration status), `rateLimit` (throttling detection), `error` (exception handling), and `emailrecovery`/`phoneNumber` (OSINT data).
- The dictionary is constructed in [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py) by the `launch_module` function, which handles both successful module execution and exception fallbacks.
- Modules like [`instagram.py`](https://github.com/megadose/holehe/blob/main/instagram.py) and [`adobe.py`](https://github.com/megadose/holehe/blob/main/adobe.py) serve as reference implementations for populating all available fields.

## Frequently Asked Questions

### What does the `exists` key indicate in Holehe results?

The `exists` key is a boolean that indicates whether the target email address is already registered on the checked service. If `True`, the account exists; if `False`, the email is either not registered or not available.

### How does Holehe handle rate limiting in the results dictionary?

When a service throttles the request or a network timeout occurs, the `rateLimit` key is set to `True`. Additionally, the `frequent_rate_limit` boolean flag indicates whether the module author has marked the service as prone to aggressive rate limiting.

### Can I extract phone numbers and recovery emails from Holehe results?

Yes. When modules support password recovery endpoints that reveal additional contact information, the `emailrecovery` and `phoneNumber` keys populate with the secondary email and phone number strings; otherwise, these fields contain `None`.

### Where is the Holehe results dictionary constructed in the source code?

The dictionary is assembled in [`holehe/core.py`](https://github.com/megadose/holehe/blob/main/holehe/core.py) within the `launch_module` function. Individual modules in `holehe/modules/` populate the values during normal execution, while the exception handler in lines 66-78 of [`core.py`](https://github.com/megadose/holehe/blob/main/core.py) generates fallback entries when modules crash.