enterprise-domain-mapper 0.1.0__tar.gz

enterprise_domain_mapper-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 GTM Layer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

enterprise_domain_mapper-0.1.0/PKG-INFO

@@ -0,0 +1,207 @@
+Metadata-Version: 2.4
+Name: enterprise-domain-mapper
+Version: 0.1.0
+Summary: Map enterprise corporate structures to enrichable domains
+Author-email: GTM Layer <hello@gtmlayer.com>
+License: MIT
+Project-URL: Homepage, https://github.com/gtmlayer/enterprise-domain-mapper
+Project-URL: Repository, https://github.com/gtmlayer/enterprise-domain-mapper
+Project-URL: Issues, https://github.com/gtmlayer/enterprise-domain-mapper/issues
+Keywords: enterprise,enrichment,abm,domains,subsidiaries,sales
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31.0
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: responses>=0.23.0; extra == "dev"
+Dynamic: license-file
+
+# Enterprise Domain Mapper
+
+[![CI](https://github.com/gtmlayer/enterprise-domain-mapper/actions/workflows/ci.yml/badge.svg)](https://github.com/gtmlayer/enterprise-domain-mapper/actions/workflows/ci.yml)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+
+**Map enterprise corporate structures to enrichable domains.** Feed it company names, get back subsidiaries, acquisitions, and regional domains that your enrichment tools are missing.
+
+Every sales team doing enterprise ABM hits the same wall: large companies have dozens of subsidiaries, acquisitions, and regional entities, each with their own email domain. Without a complete domain map, tools like Clay and Apollo only find contacts at the parent domain. Entire business units get missed.
+
+This tool fixes that.
+
+```
+$ domain-mapper "NTT Data"
+
+NTT Data
+├── NTT DATA Services        nttdataservices.com  [SEC EDGAR]
+├── NTT DATA Business Solutions  nttdata-solutions.com  [Wikipedia]
+├── Dimension Data            dimensiondata.com    [Wikipedia]
+├── NTT DATA Italia           nttdata.it           [TLD guess ✓ DNS verified]
+├── NTT DATA UK               nttdata.co.uk        [TLD guess ✓ DNS verified]
+└── NTT DATA Japan            nttdata.co.jp        [TLD guess ✓ DNS verified]
+
+Found 12 subsidiaries, 18 domains (6 confirmed, 12 guessed, 9 DNS verified)
+```
+
+## The problem
+
+Enterprise accounts don't operate under a single domain. A company like NTT Data has subsidiaries in 50+ countries, each with localised domains. Deloitte has member firms. Boeing has defence subsidiaries that use completely different brands.
+
+If you're running enrichment against just `nttdata.com`, you're finding maybe 30% of the contacts you could be reaching. The rest are hiding behind `dimensiondata.com`, `nttdata.co.uk`, `nttdata.it`, and domains you didn't know existed.
+
+Building these domain maps manually takes hours per account. We built this tool because we got tired of doing it by hand.
+
+## Quick start
+
+### Installation
+
+```bash
+pip install enterprise-domain-mapper
+```
+
+Or clone and install locally:
+
+```bash
+git clone https://github.com/gtmlayer/enterprise-domain-mapper.git
+cd enterprise-domain-mapper
+pip install -e .
+```
+
+### Single company lookup
+
+```bash
+domain-mapper "Boeing"
+```
+
+### Batch mode (CSV input)
+
+```bash
+domain-mapper accounts.csv --output results.csv
+```
+
+Your input CSV just needs a column with company names. The tool auto-detects columns named `company_name`, `company`, `name`, or `account`. If you have a domain column (`domain`, `website`, `url`), it'll use that as the parent domain for TLD guessing.
+
+### With DNS verification
+
+```bash
+domain-mapper accounts.csv --output results.csv --verify-dns
+```
+
+This checks whether guessed domains actually have mail infrastructure (MX records) or at minimum resolve (A records). Adds a few seconds per company but filters out the noise.
+
+## What it does
+
+The tool combines three data sources and a verification layer to build comprehensive domain maps:
+
+### 1. SEC EDGAR Exhibit 21 scraper
+
+For US-listed companies, SEC filings include Exhibit 21: a legally required list of all subsidiaries. The tool looks up the company's CIK, finds the latest 10-K filing, and parses the subsidiary list with jurisdictions.
+
+This is the highest-quality source - it's legally mandated disclosure, so it's comprehensive and current.
+
+### 2. Wikipedia corporate structure parser
+
+For non-US companies (or supplementary data), the tool searches Wikipedia for the company page and extracts subsidiary and acquisition data from infoboxes and structured sections.
+
+Covers companies globally, though data depth varies by how well-maintained the Wikipedia page is.
+
+### 3. TLD pattern generator
+
+Once subsidiaries are identified with their jurisdictions, the tool generates likely domain patterns. A subsidiary in Italy with parent domain `nttdata.com` produces guesses like `nttdata.it`. Covers 70+ countries with their standard corporate TLD patterns (e.g. UK produces `co.uk` and `.uk`, Japan produces `co.jp` and `.jp`).
+
+### 4. DNS verification (optional)
+
+MX record lookup with A record fallback to confirm guessed domains actually resolve. MX records are the strongest signal - if a domain has mail infrastructure, it's real. A records confirm the domain exists even without mail setup.
+
+## Output format
+
+### Detailed output (default)
+
+Nine columns, one row per subsidiary-domain pair:
+
+| Column | Description |
+|--------|-------------|
+| `parent_company` | The company you looked up |
+| `parent_domain` | Known parent domain |
+| `subsidiary_name` | Name of the subsidiary or entity |
+| `subsidiary_type` | Subsidiary, acquisition, division, etc. |
+| `jurisdiction` | Country or region |
+| `domain` | Confirmed or guessed domain |
+| `domain_source` | Where it came from (SEC EDGAR, Wikipedia, TLD guess) |
+| `dns_verified` | Whether DNS verification passed |
+| `confidence` | High (confirmed), Medium (guessed + verified), Low (guessed only) |
+
+### Clay import format
+
+One row per company with domains consolidated into a single field, ready for direct import into Clay as a data source.
+
+```bash
+domain-mapper accounts.csv --output results.csv --format clay
+```
+
+## Importing into Clay
+
+1. Run the tool with `--format clay` to get the Clay-optimised output
+2. In Clay, create a new table or add to an existing one
+3. Import the CSV - the columns map directly to Clay's expected format
+4. Use the domain list column with Clay's enrichment tools to find contacts across all mapped domains
+
+This is the workflow that sparked the whole tool. We were manually building domain maps for a client's enterprise accounts and realised the process was repeatable enough to automate.
+
+## Example
+
+The `examples/` directory contains `input_sample.csv` with five test companies to get you started:
+
+```bash
+domain-mapper examples/input_sample.csv --output examples/results.csv --verify-dns
+```
+
+## Contributing
+
+Want to add a new data source? The architecture makes it straightforward:
+
+1. Create a new module in `src/domain_mapper/sources/`
+2. Implement a class with a `get_subsidiaries(company_name)` method that returns a list of subsidiary objects
+3. Add it to the orchestrator in `mapper.py`
+4. Write tests in `tests/`
+
+Some data sources we'd love to see contributed:
+
+- Companies House (UK company registry)
+- OpenCorporates API
+- Crunchbase (acquisitions data)
+- D&B corporate hierarchies
+
+Pull requests welcome. Run `ruff check` and `black` before submitting, and make sure `pytest` passes.
+
+## Tech stack
+
+- Python 3.10+
+- `requests` and `beautifulsoup4` for web scraping
+- `click` for the CLI
+- `rich` for terminal output
+- No paid APIs, no API keys required
+
+## Built by GTM Layer
+
+[GTM Layer](https://gtmlayer.com) builds revenue systems for B2B sales teams. We work with companies on CRM architecture, enrichment pipelines, signal-driven outbound, and everything in between.
+
+This tool came out of real client work - we built it to solve a problem we kept hitting on enterprise ABM engagements. If you're running into similar challenges, [get in touch](https://gtmlayer.com).
+
+## Licence
+
+MIT - use it however you want.

enterprise_domain_mapper-0.1.0/README.md

@@ -0,0 +1,174 @@
+# Enterprise Domain Mapper
+
+[![CI](https://github.com/gtmlayer/enterprise-domain-mapper/actions/workflows/ci.yml/badge.svg)](https://github.com/gtmlayer/enterprise-domain-mapper/actions/workflows/ci.yml)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+
+**Map enterprise corporate structures to enrichable domains.** Feed it company names, get back subsidiaries, acquisitions, and regional domains that your enrichment tools are missing.
+
+Every sales team doing enterprise ABM hits the same wall: large companies have dozens of subsidiaries, acquisitions, and regional entities, each with their own email domain. Without a complete domain map, tools like Clay and Apollo only find contacts at the parent domain. Entire business units get missed.
+
+This tool fixes that.
+
+```
+$ domain-mapper "NTT Data"
+
+NTT Data
+├── NTT DATA Services        nttdataservices.com  [SEC EDGAR]
+├── NTT DATA Business Solutions  nttdata-solutions.com  [Wikipedia]
+├── Dimension Data            dimensiondata.com    [Wikipedia]
+├── NTT DATA Italia           nttdata.it           [TLD guess ✓ DNS verified]
+├── NTT DATA UK               nttdata.co.uk        [TLD guess ✓ DNS verified]
+└── NTT DATA Japan            nttdata.co.jp        [TLD guess ✓ DNS verified]
+
+Found 12 subsidiaries, 18 domains (6 confirmed, 12 guessed, 9 DNS verified)
+```
+
+## The problem
+
+Enterprise accounts don't operate under a single domain. A company like NTT Data has subsidiaries in 50+ countries, each with localised domains. Deloitte has member firms. Boeing has defence subsidiaries that use completely different brands.
+
+If you're running enrichment against just `nttdata.com`, you're finding maybe 30% of the contacts you could be reaching. The rest are hiding behind `dimensiondata.com`, `nttdata.co.uk`, `nttdata.it`, and domains you didn't know existed.
+
+Building these domain maps manually takes hours per account. We built this tool because we got tired of doing it by hand.
+
+## Quick start
+
+### Installation
+
+```bash
+pip install enterprise-domain-mapper
+```
+
+Or clone and install locally:
+
+```bash
+git clone https://github.com/gtmlayer/enterprise-domain-mapper.git
+cd enterprise-domain-mapper
+pip install -e .
+```
+
+### Single company lookup
+
+```bash
+domain-mapper "Boeing"
+```
+
+### Batch mode (CSV input)
+
+```bash
+domain-mapper accounts.csv --output results.csv
+```
+
+Your input CSV just needs a column with company names. The tool auto-detects columns named `company_name`, `company`, `name`, or `account`. If you have a domain column (`domain`, `website`, `url`), it'll use that as the parent domain for TLD guessing.
+
+### With DNS verification
+
+```bash
+domain-mapper accounts.csv --output results.csv --verify-dns
+```
+
+This checks whether guessed domains actually have mail infrastructure (MX records) or at minimum resolve (A records). Adds a few seconds per company but filters out the noise.
+
+## What it does
+
+The tool combines three data sources and a verification layer to build comprehensive domain maps:
+
+### 1. SEC EDGAR Exhibit 21 scraper
+
+For US-listed companies, SEC filings include Exhibit 21: a legally required list of all subsidiaries. The tool looks up the company's CIK, finds the latest 10-K filing, and parses the subsidiary list with jurisdictions.
+
+This is the highest-quality source - it's legally mandated disclosure, so it's comprehensive and current.
+
+### 2. Wikipedia corporate structure parser
+
+For non-US companies (or supplementary data), the tool searches Wikipedia for the company page and extracts subsidiary and acquisition data from infoboxes and structured sections.
+
+Covers companies globally, though data depth varies by how well-maintained the Wikipedia page is.
+
+### 3. TLD pattern generator
+
+Once subsidiaries are identified with their jurisdictions, the tool generates likely domain patterns. A subsidiary in Italy with parent domain `nttdata.com` produces guesses like `nttdata.it`. Covers 70+ countries with their standard corporate TLD patterns (e.g. UK produces `co.uk` and `.uk`, Japan produces `co.jp` and `.jp`).
+
+### 4. DNS verification (optional)
+
+MX record lookup with A record fallback to confirm guessed domains actually resolve. MX records are the strongest signal - if a domain has mail infrastructure, it's real. A records confirm the domain exists even without mail setup.
+
+## Output format
+
+### Detailed output (default)
+
+Nine columns, one row per subsidiary-domain pair:
+
+| Column | Description |
+|--------|-------------|
+| `parent_company` | The company you looked up |
+| `parent_domain` | Known parent domain |
+| `subsidiary_name` | Name of the subsidiary or entity |
+| `subsidiary_type` | Subsidiary, acquisition, division, etc. |
+| `jurisdiction` | Country or region |
+| `domain` | Confirmed or guessed domain |
+| `domain_source` | Where it came from (SEC EDGAR, Wikipedia, TLD guess) |
+| `dns_verified` | Whether DNS verification passed |
+| `confidence` | High (confirmed), Medium (guessed + verified), Low (guessed only) |
+
+### Clay import format
+
+One row per company with domains consolidated into a single field, ready for direct import into Clay as a data source.
+
+```bash
+domain-mapper accounts.csv --output results.csv --format clay
+```
+
+## Importing into Clay
+
+1. Run the tool with `--format clay` to get the Clay-optimised output
+2. In Clay, create a new table or add to an existing one
+3. Import the CSV - the columns map directly to Clay's expected format
+4. Use the domain list column with Clay's enrichment tools to find contacts across all mapped domains
+
+This is the workflow that sparked the whole tool. We were manually building domain maps for a client's enterprise accounts and realised the process was repeatable enough to automate.
+
+## Example
+
+The `examples/` directory contains `input_sample.csv` with five test companies to get you started:
+
+```bash
+domain-mapper examples/input_sample.csv --output examples/results.csv --verify-dns
+```
+
+## Contributing
+
+Want to add a new data source? The architecture makes it straightforward:
+
+1. Create a new module in `src/domain_mapper/sources/`
+2. Implement a class with a `get_subsidiaries(company_name)` method that returns a list of subsidiary objects
+3. Add it to the orchestrator in `mapper.py`
+4. Write tests in `tests/`
+
+Some data sources we'd love to see contributed:
+
+- Companies House (UK company registry)
+- OpenCorporates API
+- Crunchbase (acquisitions data)
+- D&B corporate hierarchies
+
+Pull requests welcome. Run `ruff check` and `black` before submitting, and make sure `pytest` passes.
+
+## Tech stack
+
+- Python 3.10+
+- `requests` and `beautifulsoup4` for web scraping
+- `click` for the CLI
+- `rich` for terminal output
+- No paid APIs, no API keys required
+
+## Built by GTM Layer
+
+[GTM Layer](https://gtmlayer.com) builds revenue systems for B2B sales teams. We work with companies on CRM architecture, enrichment pipelines, signal-driven outbound, and everything in between.
+
+This tool came out of real client work - we built it to solve a problem we kept hitting on enterprise ABM engagements. If you're running into similar challenges, [get in touch](https://gtmlayer.com).
+
+## Licence
+
+MIT - use it however you want.

enterprise_domain_mapper-0.1.0/pyproject.toml

@@ -0,0 +1,65 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "enterprise-domain-mapper"
+version = "0.1.0"
+description = "Map enterprise corporate structures to enrichable domains"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [
+    {name = "GTM Layer", email = "hello@gtmlayer.com"},
+]
+keywords = ["enterprise", "enrichment", "abm", "domains", "subsidiaries", "sales"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Office/Business",
+]
+dependencies = [
+    "requests>=2.31.0",
+    "beautifulsoup4>=4.12.0",
+    "click>=8.1.0",
+    "rich>=13.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "ruff>=0.1.0",
+    "black>=23.0",
+    "responses>=0.23.0",
+]
+
+[project.scripts]
+domain-mapper = "domain_mapper.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/gtmlayer/enterprise-domain-mapper"
+Repository = "https://github.com/gtmlayer/enterprise-domain-mapper"
+Issues = "https://github.com/gtmlayer/enterprise-domain-mapper/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W"]
+
+[tool.black]
+line-length = 100
+target-version = ["py310"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

enterprise_domain_mapper-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

enterprise_domain_mapper-0.1.0/src/domain_mapper/__init__.py

@@ -0,0 +1,3 @@
+"""Enterprise Domain Mapper - Map corporate structures to enrichable domains."""
+
+__version__ = "0.1.0"

enterprise_domain_mapper-0.1.0/src/domain_mapper/cli.py

@@ -0,0 +1,192 @@
+"""CLI interface for the Enterprise Domain Mapper."""
+
+import csv
+import logging
+import sys
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.tree import Tree
+
+from domain_mapper.mapper import DomainMapper
+from domain_mapper.models import CompanyResult
+from domain_mapper.output import write_clay_csv, write_detailed_csv
+
+console = Console()
+
+# Column name detection for CSV inputs
+COMPANY_COLUMNS = ["company_name", "company", "name", "account", "account_name", "organization"]
+DOMAIN_COLUMNS = ["domain", "website", "url", "parent_domain", "company_domain"]
+
+
+def _detect_columns(headers: list[str]) -> tuple[str | None, str | None]:
+    """Auto-detect company name and domain columns from CSV headers."""
+    headers_lower = [h.lower().strip() for h in headers]
+
+    company_col = None
+    for candidate in COMPANY_COLUMNS:
+        if candidate in headers_lower:
+            company_col = headers[headers_lower.index(candidate)]
+            break
+
+    domain_col = None
+    for candidate in DOMAIN_COLUMNS:
+        if candidate in headers_lower:
+            domain_col = headers[headers_lower.index(candidate)]
+            break
+
+    return company_col, domain_col
+
+
+def _print_tree(result: CompanyResult) -> None:
+    """Print a rich tree representation of the mapping results."""
+    tree = Tree(f"[bold]{result.company_name}[/bold]")
+
+    for domain in result.domains:
+        icon = "[green]✓[/green]" if domain.dns_verified else "[dim]·[/dim]"
+        source_tag = f"[dim][{domain.domain_source}][/dim]"
+
+        if domain.dns_verified:
+            source_tag += " [green]✓ DNS verified[/green]"
+
+        tree.add(
+            f"{icon} [cyan]{domain.subsidiary_name:<30}[/cyan] "
+            f"{domain.domain:<25} {source_tag}"
+        )
+
+    console.print(tree)
+
+    # Summary line
+    total = len(result.domains)
+    confirmed = len(result.confirmed_domains)
+    guessed = len(result.guessed_domains)
+    verified = len(result.verified_domains)
+    console.print(
+        f"\n[dim]Found {len(result.subsidiaries)} subsidiaries, "
+        f"{total} domains ({confirmed} confirmed, {guessed} guessed, "
+        f"{verified} DNS verified)[/dim]"
+    )
+
+
+@click.command()
+@click.argument("input", type=str)
+@click.option("--output", "-o", type=click.Path(), help="Output CSV file path")
+@click.option(
+    "--format",
+    "-f",
+    "output_format",
+    type=click.Choice(["detailed", "clay"]),
+    default="detailed",
+    help="Output format: detailed (one row per domain) or clay (one row per company)",
+)
+@click.option("--verify-dns", is_flag=True, help="Verify guessed domains via DNS lookups")
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose logging")
+def main(input: str, output: str | None, output_format: str, verify_dns: bool, verbose: bool):
+    """Map enterprise companies to their subsidiary domains.
+
+    INPUT can be a company name (e.g. "Boeing") or a CSV file path.
+    """
+    if verbose:
+        logging.basicConfig(level=logging.INFO, format="%(name)s: %(message)s")
+    else:
+        logging.basicConfig(level=logging.WARNING)
+
+    mapper = DomainMapper(verify_dns=verify_dns)
+    results: list[CompanyResult] = []
+
+    input_path = Path(input)
+    if input_path.exists() and input_path.suffix.lower() == ".csv":
+        # Batch mode: CSV input
+        results = _process_csv(mapper, input_path, verify_dns)
+    else:
+        # Single company mode
+        console.print(f"\n[bold]Mapping domains for:[/bold] {input}\n")
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Searching SEC EDGAR, Wikipedia, generating TLDs...", total=None)
+            result = mapper.map_company(input)
+            progress.update(task, completed=True)
+
+        results = [result]
+        _print_tree(result)
+
+    # Write output file
+    if output:
+        output_path = Path(output)
+        with open(output_path, "w", newline="", encoding="utf-8") as f:
+            if output_format == "clay":
+                write_clay_csv(results, f)
+            else:
+                write_detailed_csv(results, f)
+        console.print(f"\n[green]✓[/green] Results written to {output_path}")
+        total_domains = sum(len(r.domains) for r in results)
+        console.print(f"[dim]  {len(results)} companies, {total_domains} domains[/dim]")
+
+
+def _process_csv(mapper: DomainMapper, csv_path: Path, verify_dns: bool) -> list[CompanyResult]:
+    """Process a CSV file of companies."""
+    results = []
+
+    with open(csv_path, newline="", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        if not reader.fieldnames:
+            console.print("[red]Error: CSV file has no headers[/red]")
+            sys.exit(1)
+
+        company_col, domain_col = _detect_columns(list(reader.fieldnames))
+        if not company_col:
+            console.print(
+                f"[red]Error: Could not detect company name column. "
+                f"Expected one of: {', '.join(COMPANY_COLUMNS)}[/red]"
+            )
+            sys.exit(1)
+
+        rows = list(reader)
+
+    console.print(f"\n[bold]Processing {len(rows)} companies from {csv_path.name}[/bold]")
+    if domain_col:
+        console.print(f"[dim]Using '{company_col}' for names, '{domain_col}' for parent domains[/dim]")
+    else:
+        console.print(f"[dim]Using '{company_col}' for names (no domain column detected)[/dim]")
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        for i, row in enumerate(rows):
+            company_name = row.get(company_col, "").strip()
+            parent_domain = row.get(domain_col, "").strip() if domain_col else ""
+
+            if not company_name:
+                continue
+
+            task = progress.add_task(
+                f"[{i + 1}/{len(rows)}] {company_name}...", total=None
+            )
+            result = mapper.map_company(company_name, parent_domain)
+            results.append(result)
+            progress.update(task, completed=True, description=f"[{i + 1}/{len(rows)}] {company_name}: {len(result.domains)} domains")
+
+    # Print summary
+    total_subs = sum(len(r.subsidiaries) for r in results)
+    total_domains = sum(len(r.domains) for r in results)
+    total_verified = sum(len(r.verified_domains) for r in results)
+
+    console.print(f"\n[bold]Summary[/bold]")
+    console.print(f"  Companies processed: {len(results)}")
+    console.print(f"  Total subsidiaries found: {total_subs}")
+    console.print(f"  Total domains mapped: {total_domains}")
+    if verify_dns:
+        console.print(f"  DNS verified: {total_verified}")
+
+    return results
+
+
+if __name__ == "__main__":
+    main()