Understanding the holehe `others` Field: What Additional Information Beyond Basic Email Detection Gets Captured

The others field in holehe module output is a flexible dictionary that stores supplementary account metadata beyond simple existence detection, including full names, account creation timestamps, and error messages.

The open-source OSINT tool holehe by megadose checks whether an email address is registered across hundreds of services. While the core detection returns a Boolean exists flag, the holehe others field provides an extensible container for enriched data that services expose during the verification process.

What the holehe others Field Contains

Every holehe module returns a standardized result dictionary. The others key is deliberately designed as None when no extra data surfaces, or as a populated dictionary when services leak account metadata.

Based on the source code in holehe/core.py, the others dictionary may include these keys:

Key	Description	Source Module Example
FullName	Real name associated with the email/account	odnoklassniki
Date, time of the creation	ISO-formatted timestamp of account registration	odnoklassniki
errorMessage	Human-readable error or rate-limit notification	facebook, instagram, and others
Service-specific fields	Profile URLs, public IDs, or custom metadata	Varies per module

The handling logic in holehe.core.print_result (lines 28-45) conditionally displays these fields:

# From holehe/core.py - simplified extraction

if result["others"] is not None:
    if "FullName" in result["others"]:
        display_line += f" [{result['others']['FullName']}]"
    if "Date, time of the creation" in result["others"]:
        display_line += f" ({result['others']['Date, time of the creation']})"
    if "errorMessage" in result["others"]:
        display_line += f" [! {result['others']['errorMessage']}]"

How Modules Populate the others Field

Standard Pattern: Minimal Response

Most modules return no additional metadata. The pattern implemented across holehe/modules/ follows this structure:

# Typical module response when only existence is verified

return [{
    "name": "example_service",
    "domain": "example.com", 
    "method": "register",
    "frequent_rate_limit": False,
    "rateLimit": False,
    "exists": True,  # or False

    "emailrecovery": None,
    "phoneNumber": None,
    "others": None   # No extra data available

}]

Enriched Response: Account Metadata Extraction

The odnoklassniki module (holehe/modules/social_media/odnoklassniki.py) demonstrates full others field utilization. When querying OK.ru, it parses account creation dates and display names from API responses:

# Example structure from odnoklassniki module

others_dict = {
    "FullName": "Алексей Петров",
    "Date, time of the creation": "2012-07-08T14:23:11Z"
}
return [{
    "name": "odnoklassniki",
    "domain": "ok.ru",
    "exists": True,
    "others": others_dict,  # Populated with account metadata

    # ... remaining fields

}]

Error State Handling

Several modules utilize others to surface diagnostic information when requests fail. Rather than silencing errors, these implementations preserve context:

# Pattern seen in modules handling structured errors

return [{
    "name": "facebook",
    "exists": False,
    "others": {
        "errorMessage": "Request blocked: checkpoint required"
    },
    # ... remaining fields

}]

Accessing others Data Programmatically

The holehe others field is fully exposed in JSON output for downstream processing:

# Execute scan and filter for enriched results

holehe -C target@email.com --only-used -j | jq '.[] | select(.others != null)'

# Sample output

{
  "name": "odnoklassniki",
  "domain": "ok.ru",
  "exists": true,
  "others": {
    "FullName": "Maria Ivanova",
    "Date, time of the creation": "2010-11-30T09:15:00Z"
  }
}

For Python integration:

import subprocess
import json

def extract_enriched_accounts(email):
    """Return services with non-trivial `others` data."""
    result = subprocess.run(
        ["holehe", "-C", email, "-j"],
        capture_output=True, text=True
    )
    data = json.loads(result.stdout)
    
    enriched = []
    for entry in data:
        if entry.get("others") is not None:
            enriched.append({
                "service": entry["name"],
                "exists": entry["exists"],
                "metadata": entry["others"]
            })
    return enriched

# Usage

accounts = extract_enriched_accounts("user@example.com")
for acc in accounts:
    print(f"{acc['service']}: {acc['metadata']}")

Core Implementation Details

The result formatting in holehe/core.py explicitly branches on others content type. This implementation (around lines 28-45) ensures backward compatibility—modules returning None skip enrichment, while structured data triggers appropriate formatting:

• Name appending: FullName values attach bracketed identifiers
• Timestamp display: Creation dates render in parentheses
• Error annotation: errorMessage values prepend warning indicators

This design allows the holehe others field to evolve without breaking existing output parsers.

Module Implementation Guidelines

When developing custom holehe modules, the others field accepts any JSON-serializable dictionary. Per the codebase convention:

• Use descriptive keys matching service API field names
• Include timestamps in ISO 8601 format when available
• Reserve errorMessage for human-readable failure explanations
• Return None rather than empty dictionaries for clean results

Summary

• The holehe others field is an optional dictionary capturing auxiliary account metadata beyond basic email existence detection
• FullName and Date, time of the creation are standard keys extracted by services like odnoklassniki
• errorMessage preserves context when requests fail due to rate limits or blocks
• Implementation resides in holehe/core.py with module-specific population in holehe/modules/
• All modules return None for others when no supplementary data exists, maintaining output consistency

Frequently Asked Questions

What happens if a service provides unexpected fields in others?

Any additional keys beyond the standard set are preserved in JSON output but not rendered in terminal display. The print_result function explicitly checks for known keys (FullName, Date, time of the creation, errorMessage) while passing through the full dictionary structure. This allows extensibility without breaking existing integrations.

Can others contain nested data structures?

Yes. While most implementations use flat dictionaries, the JSON schema permits nested objects. The terminal formatter in holehe/core.py only surfaces top-level keys it recognizes; complex nested data remains accessible through programmatic JSON consumption via the -j flag.

Why do most modules return None for others?

Services vary dramatically in data leakage patterns. The majority implement registration-check endpoints that reveal only existence state without account metadata. The others field activates only when response analysis yields verifiable auxiliary information, prioritizing accuracy over speculation.

How can I contribute a module that populates others?

Follow the pattern in holehe/modules/social_media/odnoklassniki.py: parse API responses for account creation dates, display names, or profile identifiers; construct a dictionary with descriptive keys; and assign it to the others field in your return statement. Ensure your module handles None gracefully when enrichment data is unavailable.

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