Last updated: March 16, 2026

Executors must systematically identify, document, and manage hundreds of online accounts to prevent asset loss and identity theft. This guide provides practical discovery methods, email analysis, CLI tools, Have I Been Pwned API checks, and structured inventory templates, to document financial accounts, social media, cloud storage, and subscriptions. Use Python scripts and automation to accelerate account discovery and track completion of priority actions.

Table of Contents

Understanding the Scope of Digital Estate

Modern digital life encompasses far more than most people realize. The average user maintains over 100 online accounts across various services. For executors, this means tracking:

The executor must locate credentials, understand what each account contains, determine its value (monetary or sentimental), and take appropriate action, whether transferring ownership, closing accounts, or memorializing profiles.

Systematic Discovery Methods

Step 1 - Physical and Digital Search

Begin with a thorough physical search of the deceased’s home office:

Digital discovery involves checking:

Step 2 - Email Account Analysis

The deceased’s primary email account often serves as an account registry. Use email search with these queries:

Subject - "welcome" OR "verify" OR "confirm your account"
From - "noreply@*.com" OR "support@*.com"

This reveals registration confirmations across thousands of services. Export relevant emails to a searchable format for systematic review.

Step 3 - Using CLI Tools for Account Discovery

For developers and power users, command-line tools accelerate the discovery process. Here’s a Python script that analyzes exported email to identify service accounts:

#!/usr/bin/env python3
"""
Email Account Discovery Tool for Estate Executors
Analyzes email exports to identify online service accounts.
"""

import re
import csv
import os
from pathlib import Path
from collections import defaultdict

Common service patterns for account identification
SERVICE_PATTERNS = {
    'financial': [
        r'chase|bank of america|wells fargo|citibank|pnc',
        r'paypal|venmo|square|cash app',
        r'fidelity|schwab|vanguard|fidelity',
        r'coinbase|binance|kraken|blockchain',
    ],
    'social': [
        r'facebook|instagram|twitter|x\.com|linkedin',
        r'tiktok|snapchat|reddit|pinterest',
    ],
    'streaming': [
        r'netflix|spotify|hulu|disney\+|hbo',
        r'youtube|twitch|amazon prime',
    ],
    'cloud': [
        r'google drive|drive\.google|dropbox|icloud',
        r'onedrive|mega|box\.com',
    ],
}

def analyze_email_file(filepath):
    """Analyze email file and extract service mentions."""
    accounts = defaultdict(list)

    service_indicators = [
        (r'welcome to ([a-zA-Z0-9]+)', 'registration'),
        (r'your ([a-zA-Z0-9]+) account', 'account'),
        (r'confirm your email.*?([a-zA-Z0-9]+)', 'verification'),
    ]

    # Read and analyze email content
    with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
        content = f.read().lower()

        for category, patterns in SERVICE_PATTERNS.items():
            for pattern in patterns:
                matches = re.findall(pattern, content)
                for match in matches:
                    accounts[category].append({
                        'service': match,
                        'type': 'identified',
                    })

    return accounts

def generate_inventory_report(accounts, output_file='estate_accounts.csv'):
    """Generate CSV report of discovered accounts."""
    with open(output_file, 'w', newline='') as f:
        writer = csv.writer(f)
        writer.writerow(['Category', 'Service', 'Action Required', 'Priority', 'Notes'])

        priorities = {
            'financial': 'HIGH',
            'social': 'MEDIUM',
            'streaming': 'MEDIUM',
            'cloud': 'HIGH',
        }

        for category, services in accounts.items():
            for service in services:
                writer.writerow([
                    category,
                    service['service'],
                    'Review and close/transfer',
                    priorities.get(category, 'LOW'),
                    ''
                ])

    print(f"Inventory report generated: {output_file}")

if __name__ == '__main__':
    import sys

    if len(sys.argv) < 2:
        print("Usage - python account_discovery.py <email_export_directory>")
        sys.exit(1)

    email_dir = Path(sys.argv[1])
    all_accounts = defaultdict(list)

    for email_file in email_dir.glob('*'):
        if email_file.is_file():
            accounts = analyze_email_file(email_file)
            for category, services in accounts.items():
                all_accounts[category].extend(services)

    generate_inventory_report(all_accounts)

Step 4 - Using Have I Been Pwned for Breach Data

The deceased’s email address may have appeared in data breaches, revealing account existence at specific services. Use the Have I Been Pwned API to check:

#!/bin/bash
Check email for breach data
Requires - curl, jq

EMAIL="deceased@example.com"
HIBP_API="https://haveibeenpwned.com/api/v3/breachedaccount/$EMAIL"

curl -s -H "User-Agent: EstateExecutorTool" \
     -H "hibp-api-key: YOUR_API_KEY" \
     "$HIBP_API" | jq '.[] | {Name, BreachDate, DataClasses}'

This reveals services where the email was compromised, indicating active or former accounts.

Building the Inventory Template

Create a structured inventory using this template structure:

{
  "estate_inventory": {
    "deceased_name": "",
    "date_of_death": "",
    "executor_name": "",
    "accounts": [
      {
        "id": 1,
        "service_name": "",
        "service_url": "",
        "account_type": "financial|social|cloud|subscription|other",
        "username": "",
        "email_associated": "",
        "password_status": "found|needs_reset|managed_by_family",
        "priority": "high|medium|low",
        "action_required": "close|transfer|memorialize|await_instructions",
        "monetary_value": 0,
        "sentimental_value": "none|low|medium|high",
        "notes": "",
        "date_documented": "",
        "completed": false
      }
    ],
    "password_manager": {
      "type": "",
      "master_password_location": "",
      "vault_accessible": true
    },
    "2fa_methods": {
      "authenticator_app": true,
      "backup_codes_location": "",
      "recovery_email": "",
      "recovery_phone": ""
    }
  }
}

Export this template to CSV or a database for collaborative editing among family members.

Automating Documentation with Custom Scripts

For managing multiple accounts efficiently, create automation scripts:

#!/usr/bin/env python3
"""
Estate Account Manager
Tracks and manages digital accounts during estate administration.
"""

import json
import csv
from datetime import datetime
from pathlib import Path

class EstateAccountManager:
    def __init__(self, inventory_file='estate_inventory.json'):
        self.inventory_file = Path(inventory_file)
        self.data = self._load_inventory()

    def _load_inventory(self):
        if self.inventory_file.exists():
            with open(self.inventory_file) as f:
                return json.load(f)
        return {"accounts": [], "metadata": {}}

    def add_account(self, service_name, account_type, priority='medium',
                    monetary_value=0, notes=''):
        account = {
            "id": len(self.data['accounts']) + 1,
            "service_name": service_name,
            "account_type": account_type,
            "priority": priority,
            "monetary_value": monetary_value,
            "notes": notes,
            "date_documented": datetime.now().isoformat(),
            "completed": False
        }
        self.data['accounts'].append(account)
        self._save_inventory()
        return account['id']

    def mark_completed(self, account_id):
        for account in self.data['accounts']:
            if account['id'] == account_id:
                account['completed'] = True
                account['date_completed'] = datetime.now().isoformat()
        self._save_inventory()

    def get_pending_accounts(self, priority=None):
        accounts = [a for a in self.data['accounts'] if not a['completed']]
        if priority:
            accounts = [a for a in accounts if a['priority'] == priority]
        return accounts

    def generate_summary(self):
        total = len(self.data['accounts'])
        completed = len([a for a in self.data['accounts'] if a['completed']])
        pending = total - completed
        total_value = sum(a.get('monetary_value', 0) for a in self.data['accounts'])

        return {
            "total_accounts": total,
            "completed": completed,
            "pending": pending,
            "total_monetary_value": total_value
        }

    def _save_inventory(self):
        with open(self.inventory_file, 'w') as f:
            json.dump(self.data, f, indent=2)

if __name__ == '__main__':
    manager = EstateAccountManager()

    # Add discovered accounts
    manager.add_account("Chase Bank", "financial", "high", 50000, "Primary checking")
    manager.add_account("Netflix", "subscription", "low", 15, "Family plan")
    manager.add_account("GitHub", "developer", "medium", 0, "Contains code repositories")

    # Print status
    summary = manager.generate_summary()
    print(f"Estate Account Summary:")
    print(f"  Total: {summary['total_accounts']}")
    print(f"  Completed: {summary['completed']}")
    print(f"  Pending: {summary['pending']}")
    print(f"  Value: ${summary['total_monetary_value']}")

Priority Actions by Account Type

Financial Accounts (Highest Priority)

Contact institutions directly with death certificate and executor documentation. Many banks require:

Close or transfer accounts systematically, maintaining records of all communications.

Social Media Accounts

Major platforms offer memorialization or deletion options:

Subscription Services

Cancel recurring payments to prevent unauthorized charges. Document cancellation confirmations for records.

Cloud Storage

Transfer ownership of important data to family members. Ensure photos, documents, and creative works are preserved before closing accounts.

Security Considerations

During estate administration, protect against identity theft:

  1. Freeze credit at major bureaus (Equifax, Experian, TransUnion)
  2. Change passwords on critical accounts if you have legal authority
  3. Monitor for fraud using identity theft protection services
  4. Document everything in case of disputes

Frequently Asked Questions

How long does it take to document all online accounts for executor of estate?

For a straightforward setup, expect 30 minutes to 2 hours depending on your familiarity with the tools involved. Complex configurations with custom requirements may take longer. Having your credentials and environment ready before starting saves significant time.

What are the most common mistakes to avoid?

The most frequent issues are skipping prerequisite steps, using outdated package versions, and not reading error messages carefully. Follow the steps in order, verify each one works before moving on, and check the official documentation if something behaves unexpectedly.

Do I need prior experience to follow this guide?

Basic familiarity with the relevant tools and command line is helpful but not strictly required. Each step is explained with context. If you get stuck, the official documentation for each tool covers fundamentals that may fill in knowledge gaps.

Is this approach secure enough for production?

The patterns shown here follow standard practices, but production deployments need additional hardening. Add rate limiting, input validation, proper secret management, and monitoring before going live. Consider a security review if your application handles sensitive user data.

Where can I get help if I run into issues?

Start with the official documentation for each tool mentioned. Stack Overflow and GitHub Issues are good next steps for specific error messages. Community forums and Discord servers for the relevant tools often have active members who can help with setup problems.

Related Articles