# Email Combination Generator (`codescraper/email-combination-generator`) Actor Generate professional email combinations with this Email Combination Generator. Create email patterns from names and company domains in bulk or individually. Supports initials, middle names, nicknames, separators and birth years for B2B lead generation, email finding and verification workflows. - **URL**: https://apify.com/codescraper/email-combination-generator.md - **Developed by:** [CodeScraper](https://apify.com/codescraper) (community) - **Categories:** Lead generation, Automation, Developer tools - **Stats:** 3 total users, 3 monthly users, 97.2% runs succeeded, 2 bookmarks - **User rating**: 5.00 out of 5 stars ## Pricing from $1.00 / 1,000 user combinations generateds This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. - **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use). - **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`. - **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`. - **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`. - **Any other language** — the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## ⭐ Email Combination Generator – B2B Lead Generation & Email Pattern Discovery This Apify Actor generates **likely professional email-address combinations** from a person's name and company domain. It supports both **single-user** and **bulk processing**, with optional middle names, nicknames, and birth years. The actor intelligently creates combinations using common corporate email naming patterns, multiple separators, initials, name ordering, and optional birth-year suffixes — all packaged into a structured dataset ready for downstream lead-generation and enrichment workflows. > ⚠️ **Important:** This actor generates possible email addresses based on naming patterns. It does **not** verify that an email address exists, belongs to the intended person, or is deliverable. *** ### 🚀 What It Does For every person and company domain provided, the actor generates a broad set of possible professional email combinations. #### 👤 Person Data The actor can process: - **🧑** First Name - **🧑** Middle Name (Optional) - **👤** Last Name - **🏷️** Nickname (Optional) - **📅** Birth Year (Optional) - **🏢** Company Domain For bulk processing, you can provide a list of names and a corresponding list of company domains. The lists must match in length and order. *** ### 📦 Processing Modes #### 🔹 Bulk Processing Provide: - A list of names - A matching list of company domains - An optional global birth year Each name is paired with the domain at the **same list position**. Example: ```text Names: Tim Cook Elon Musk Sundar Pichai Domains: apple.com tesla.com google.com ``` The actor processes them as: ```text Tim Cook → apple.com Elon Musk → tesla.com Sundar Pichai → google.com ``` The actor strictly validates that the number of names and domains is equal before processing. #### 🔹 Single User Processing For a single person, you can provide: - First Name - Middle Name - Last Name - Nickname - Birth Year - Company Domain The company domain is required for single-user processing. *** ### ✉️ Email Combination Generation The actor generates combinations using: #### Basic Name Parts - Full first name - First-name initial - Full last name - Last-name initial #### Two-Part Combinations Examples include patterns based on: ```text firstname + lastname firstname + lastinitial firstinitial + lastname firstinitial + lastinitial lastname + firstname lastname + firstinitial lastinitial + firstname lastinitial + firstinitial ``` #### Separators Each supported combination can be generated using: - No separator - `.` - `-` - `_` For example: ```text john.doe@example.com john-doe@example.com john_doe@example.com johndoe@example.com ``` *** ### 🧩 Middle Name Support When a middle name is available, the actor generates additional combinations using: - First + Middle + Last - First + Middle Initial + Last - First Initial + Middle Initial + Last - First Initial + Middle + Last - First + Middle + Last Initial - First Initial + Middle Initial + Last Initial It also generates first/middle combinations such as: ```text john.donald@example.com j.donald@example.com john.d@example.com j.d@example.com ``` with the supported separators. *** ### 🏷️ Nickname Support When a nickname and last name are provided, additional combinations are generated using: - Nickname + Last Name - Nickname + Last Initial - Last Name + Nickname - Last Initial + Nickname For example: ```text timmy.cook@example.com timmy.c@example.com cook.timmy@example.com c.timmy@example.com ``` *** ### 📅 Birth Year Support An optional birth year can be appended to **all combinations generated for a person**. Supported formats: - `90` - `1990` For example: ```text john.doe90@example.com john.doe1990@example.com jdoe90@example.com jdoe1990@example.com ``` In bulk mode, the optional `globalBirthYear` is applied to all bulk users. *** ### 🧹 Smart Name Normalization Before generating combinations, the actor sanitizes names by: - Converting names to lowercase - Removing apostrophes - Removing spaces - Removing periods - Removing hyphens For example: ```text O'Connor → oconnor Mary Jane → maryjane Anne-Marie → annemarie ``` This helps create cleaner corporate-style email prefixes. *** ### 🛡️ Input Validation The actor validates inputs before processing. #### Name Validation Names: - Cannot contain numbers - Have maximum length limits - Support first, middle, last, nickname, and full-name inputs #### Birth Year Validation Birth years must contain exactly: - **2 digits**, or - **4 digits** Examples: ```text 90 1990 ``` #### Domain Validation Domains must follow a valid domain format such as: ```text example.com company.co.uk startup.io ``` #### Bulk Validation The actor requires the names and domains arrays to have the same number of entries. If they do not match, processing fails with a clear validation error. *** ### ⚡ It Handles - **✅** Single-person email combination generation - **✅** Bulk name + domain processing - **👤** First, middle, and last names - **🏷️** Nickname-based combinations - **📅** Optional birth-year combinations - **🔀** Multiple name ordering patterns - **🔤** Initial-based combinations - **➖** Multiple separators (`.`, `-`, `_`, or none) - **🧹** Automatic duplicate removal - **🧼** Name sanitization and normalization - **🎯** Maximum combination limits - **📦** Structured Apify Dataset output *** ### 🧠 How It Works 1. Reads the Actor input. 2. Determines whether bulk or single-user targets were supplied. 3. Validates names, domains, and optional birth years. 4. Converts full names into first and last-name components when necessary. 5. Normalizes names for corporate email formatting. 6. Builds combinations from names, initials, middle names, and nicknames. 7. Applies supported separators to applicable combinations. 8. Adds optional birth-year suffixes. 9. Removes duplicate combinations automatically. 10. Applies the optional `maxCombinations` limit. 11. Pushes structured results to the Apify Dataset. *** ### ⚙️ Input Configuration | Field | Type | Required | Description | | ----------------- | ------- | ---------- | ------------------------------------------------------------------------------ | | `namesList` | Array | For bulk | List of full names or first names. Names cannot contain numbers. | | `domainsList` | Array | For bulk | Company domains corresponding to `namesList` in the exact same order. | | `globalBirthYear` | String | No | 2- or 4-digit birth year applied to all bulk combinations. | | `companyDomain` | String | For single | Company domain for single-user processing. | | `firstName` | String | No | Person's first name. | | `middleName` | String | No | Person's middle name. | | `lastName` | String | No | Person's last name. | | `nickname` | String | No | Person's nickname. | | `birthYear` | String | No | 2- or 4-digit birth year for a single user. | | `maxCombinations` | Integer | No | Maximum number of emails generated per user. Leave empty for all combinations. | The Actor input schema defines `namesList` and `domainsList` for bulk processing, while the individual name fields and `companyDomain` are used for single-user processing. *** ### 🧩 Example Input – Bulk ```json { "namesList": ["Tim Cook", "Elon Musk", "Sundar Pichai"], "domainsList": ["apple.com", "tesla.com", "google.com"], "globalBirthYear": "90", "maxCombinations": 20 } ``` The corresponding name/domain positions are paired together by the Actor. *** ### 🧩 Example Input – Single User ```json { "firstName": "Tim", "middleName": "Donald", "lastName": "Cook", "nickname": "Timmy", "companyDomain": "apple.com", "birthYear": "1960", "maxCombinations": 50 } ``` The single-user form requires `companyDomain` when a single target is supplied. *** ### 📊 Example Output A dataset item generated by the Actor follows this structure: ```json { "firstName": "Tim", "lastName": "Cook", "domain": "apple.com", "totalCombinations": 20, "combinations": [ "tim@apple.com", "t@apple.com", "cook@apple.com", "c@apple.com", "tim.cook@apple.com", "tim-cook@apple.com", "tim_cook@apple.com", "timcook@apple.com", "t.cook@apple.com", "t-cook@apple.com", "t_cook@apple.com", "tcook@apple.com", "cook.tim@apple.com", "cook-tim@apple.com", "cook_tim@apple.com", "cooktim@apple.com", "c.tim@apple.com", "c-tim@apple.com", "c_tim@apple.com", "ctim@apple.com" ] } ``` The Actor pushes `firstName`, `lastName`, normalized `domain`, `totalCombinations`, and the generated `combinations` array to the Apify Dataset. *** ### 📈 Output Fields | Field | Description | | ------------------- | ---------------------------------------------- | | `firstName` | Parsed or supplied first name. | | `lastName` | Parsed or supplied last name. | | `domain` | Normalized company domain. | | `totalCombinations` | Number of combinations generated for the user. | | `combinations` | Array containing generated email addresses. | The domain is normalized by lowercasing it, removing `http://` or `https://`, removing `www.`, and stripping any path after the hostname. *** ### 🎯 Maximum Combinations Use `maxCombinations` when you want to limit the number of generated emails per person. Example: ```json { "maxCombinations": 10 } ``` If a limit is provided and greater than zero, the Actor keeps only the first requested number of generated combinations. *** ### ⭐ Features - **🚀 Bulk Processing** — Generate combinations for many people in one Actor run. - **👤 Single User Mode** — Generate combinations for an individual person. - **🧑‍🤝‍🧑 Full Name Parsing** — Full names can be split into first and last-name components. - **🧠 Multiple Patterns** — Supports many common corporate email naming structures. - **🔤 Initial Combinations** — Uses first, middle, and last initials where applicable. - **🔀 Multiple Separators** — Supports `.`, `-`, `_`, and no separator. - **🏷️ Nickname Patterns** — Adds nickname-based combinations when supplied. - **📅 Birth-Year Patterns** — Optionally appends 2- or 4-digit birth years. - **🧹 Deduplication** — Uses a `Set` to prevent duplicate prefixes. - **🛡️ Validation** — Rejects malformed domains, numeric names, and invalid birth-year formats. - **🎛️ Combination Limits** — Control output size with `maxCombinations`. - **📦 Structured Output** — Results are pushed directly to an Apify Dataset. *** ### 💡 Use Cases - B2B Lead Generation - Sales Prospecting - Email Pattern Discovery - Contact Data Enrichment - CRM Enrichment - Company Research - Sales Intelligence - Recruitment & HR Sourcing - Business Directory Building - Email Verification Workflows - Prospect Research Automation *** ### 🔍 Email Verification This Actor is a **combination generator**, not an email verifier. Generated addresses should be treated as candidates. For example: ```text john.doe@example.com jdoe@example.com john@example.com ``` do not necessarily mean that those mailboxes exist. For higher-confidence lead data, send the generated combinations through a separate email verification or validation workflow before using them for outreach. *** ### ❓ FAQs #### 1. Can I process multiple people at once? Yes. Use `namesList` and `domainsList` for bulk processing. Each name is paired with the domain at the same position in the two arrays. *** #### 2. Do the bulk arrays need to be the same length? Yes. The Actor strictly validates that the number of names matches the number of domains. If one list has extra entries, the Actor fails the run instead of silently creating incorrect pairings. *** #### 3. Can I provide only a full name? Yes. When a `fullName` is available and first/last names are not supplied, the Actor splits the first word into the first name and the remaining words into the last name. *** #### 4. Can I include a middle name? Yes. Middle-name combinations are generated when both middle and other relevant name parts are available. *** #### 5. Can I include a nickname? Yes. Nickname + last-name and last-name + nickname combinations are supported. *** #### 6. Can I add a birth year? Yes. Birth years can be supplied as exactly 2 or 4 digits, such as: ```text 90 1990 ``` The birth year is appended to generated prefixes using the supported separators. *** #### 7. Does the Actor remove duplicate combinations? Yes. Email prefixes are stored in a `Set`, so duplicate combinations are automatically removed before the final email list is created. *** #### 8. Can I limit the number of emails generated? Yes. Set `maxCombinations` to a positive integer to limit the number of generated emails per user. *** #### 9. Does it verify whether the emails exist? No. It generates possible email addresses only. A separate verification step is recommended before outreach. *** #### 10. What happens if no target is provided? The Actor fails with a validation error asking for either bulk lists or the single-user form. *** ### 🧑‍💻 Developer Info **Author:** codescraper\ **Email:** codescraper011@gmail.com *** ### 🏷️ Tags `email-combination-generator` · `email-generator` · `email-pattern-generator` · `email-finder` · `b2b-leads` · `lead-generation` · `sales-intelligence` · `prospecting` · `email-enrichment` · `contact-data` · `business-research` · `apify` · `automation` *** ### ⚠️ Responsible Use Use generated email combinations responsibly and in accordance with applicable privacy, anti-spam, data-protection, and outreach laws and regulations. This Actor provides **candidate email combinations**, not verified personal contact information. Always use appropriate validation and ensure you have a lawful basis and appropriate authorization for your intended use. # Actor input Schema ## `namesList` (type: `array`): Enter names one by one. Can be Full Names (e.g., Tim Cook) or First Names. No numbers allowed. ## `domainsList` (type: `array`): Enter the corresponding domains matching the exact order of the names above. ## `globalBirthYear` (type: `string`): Exactly 2 or 4 digits (e.g., 90 or 1990). If provided, applies to ALL bulk combinations. ## `companyDomain` (type: `string`): Required for single user. (e.g., spacex.com) ## `firstName` (type: `string`): Optional. (e.g., Tim) ## `middleName` (type: `string`): Optional. (e.g., Donald) ## `lastName` (type: `string`): Optional. (e.g., Cook) ## `nickname` (type: `string`): Optional. (e.g., Timmy) ## `birthYear` (type: `string`): Optional. Exactly 2 or 4 digits (e.g., 90 or 1990) ## `maxCombinations` (type: `integer`): Optional. Limit the number of emails generated per person (e.g. enter 10). Leave empty for all. ## Actor input object example ```json { "namesList": [ "Tim Cook", "Elon Musk", "Sundar Pichai" ], "domainsList": [ "spacex.com", "tesla.com", "google.com" ] } ``` # Actor output Schema ## `full_dataset` (type: `string`): Download the complete dataset of generated email combinations in JSON format. # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "namesList": [ "Tim Cook", "Elon Musk", "Sundar Pichai" ], "domainsList": [ "spacex.com", "tesla.com", "google.com" ] }; // Run the Actor and wait for it to finish const run = await client.actor("codescraper/email-combination-generator").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "namesList": [ "Tim Cook", "Elon Musk", "Sundar Pichai", ], "domainsList": [ "spacex.com", "tesla.com", "google.com", ], } # Run the Actor and wait for it to finish run = client.actor("codescraper/email-combination-generator").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "namesList": [ "Tim Cook", "Elon Musk", "Sundar Pichai" ], "domainsList": [ "spacex.com", "tesla.com", "google.com" ] }' | apify call codescraper/email-combination-generator --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,codescraper/email-combination-generator" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/EJQsB6o4MlwchCKHp/builds/VMNpfeWeovakSmiGy/openapi.json