Discover emails across multiple domains, set limits, filter by type/seniority, specify departments, and obtain required fields with the 'Domain Email Search' actor. Pay only for returned emails. Simplify contact discovery for sales, marketing, and outreach efforts.

hunter.io-domain-search

package.json

hunter-domain-search

Hunter Domain Search

.actor/actor.json

Overview

.actor/dataset_schema.json

🔑 API Key

Communication

Design

For example, 'stripe.com' or 'stripe'. Note that you'll get better results by supplying the domain name as we won't have to find it. It doesn't need to be in lowercase.

Domain or company name from which you want to find the email addresses.

Education

Executive

Finance

Full Name

Health

Junior

Legal

Specifies the max number of email addresses to return.

Management

Marketing

Specifies the number of email addresses to skip.

Operations

Phone Number

Position

Sales

Senior

Support

Choose personal emails, generic emails, or select all.

Get only personal or generic email addresses.

Domain Search

.actor/input_schema.json

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const dotenv_1 = __importDefault(require("dotenv"));
dotenv_1.default.config();
const node_fetch_1 = __importDefault(require("node-fetch"));
const apify_1 = require("apify");
const utils_1 = require("./utils");
const types_1 = require("./types");
(async () => {
    try {
        await apify_1.Actor.init();
        const { domain, apiKey, limit, offset, type, seniorityLevels, departments, requiredFields, } = await getActorInput();
        const API_ENDPOINT = `https://api.hunter.io/v2/domain-search?api_key=${apiKey}`;
        const baseUrl = buildBaseUrl(API_ENDPOINT, domain, limit, offset, type, seniorityLevels, departments, requiredFields);
        const data = await fetchEmailData(baseUrl);
        if (!data?.emails?.length)
            apify_1.log.info(`No emails found for ${domain}`);
        if (data.emails.length)
            await logAndSaveData(domain, data);
        // add rate limit of 10 requests per second
        await (0, utils_1.delay)(100);
    }
    catch (err) {
        apify_1.log.error(err.message);
    }
    finally {
        await apify_1.Actor.exit();
    }
})();
const getActorInput = async () => {
    const input = await apify_1.Actor.getInput();
    const { domain, api_key: apiKey, limit, offset, type, } = input;
    if (!apiKey)
        throw new Error("No API key supplied!");
    if (!domain)
        throw new Error("No domain or company provided!");
    return {
        domain,
        apiKey,
        limit,
        offset,
        type,
        seniorityLevels: (0, utils_1.getEnumVal)(types_1.Seniority, input),
        departments: (0, utils_1.getEnumVal)(types_1.Departments, input),
        requiredFields: (0, utils_1.getEnumVal)(types_1.RequiredFields, input),
    };
};
const fetchEmailData = async (baseUrl) => {
    const response = await (0, node_fetch_1.default)(baseUrl);
    if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
    }
    const jsonResponse = await response.json();
    const { data } = jsonResponse;
    return data;
};
const logAndSaveData = async (domain, data) => {
    const emailCount = data.emails.length;
    apify_1.log.info(`Found ${emailCount} emails for ${domain}`);
    await saveResults(domain, data);
};
function buildBaseUrl(endpoint, domain, limit, offset, type, seniorityLevels, departments, requiredFields) {
    const url = new URL(endpoint);
    if ((0, utils_1.isNumeric)(limit))
        url.searchParams.append("limit", limit);
    if ((0, utils_1.isNumeric)(offset))
        url.searchParams.append("offset", offset);
    if (type === "personal" || type === "generic")
        url.searchParams.append("type", type);
    if (seniorityLevels.length)
        url.searchParams.append("seniority", seniorityLevels.join());
    if (departments.length)
        url.searchParams.append("department", departments.join());
    if (requiredFields.length)
        url.searchParams.append("required_field", requiredFields.join());
    // check if domain or company is provided
    const isDomainProvided = (0, utils_1.isDomain)(domain);
    if (isDomainProvided)
        url.searchParams.append("domain", domain);
    if (!isDomainProvided)
        url.searchParams.append("company", domain);
    return url.toString();
}
async function saveResults(domain, data) {
    for (const email of data.emails) {
        await apify_1.Actor.pushData(Object.assign({ domain }, email));
    }
}


dist/main.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.RequiredFields = exports.Departments = exports.Seniority = void 0;
var Seniority;
(function (Seniority) {
    Seniority["junior"] = "junior";
    Seniority["senior"] = "senior";
    Seniority["executive"] = "executive";
})(Seniority = exports.Seniority || (exports.Seniority = {}));
var Departments;
(function (Departments) {
    Departments["executives"] = "executive";
    Departments["it"] = "it";
    Departments["finance"] = "finance";
    Departments["management"] = "management";
    Departments["sales"] = "sales";
    Departments["legal"] = "legal";
    Departments["support"] = "support";
    Departments["hr"] = "hr";
    Departments["marketing"] = "marketing";
    Departments["communication"] = "communication";
    Departments["education"] = "education";
    Departments["design"] = "design";
    Departments["health"] = "health";
    Departments["operations"] = "operations";
})(Departments = exports.Departments || (exports.Departments = {}));
var RequiredFields;
(function (RequiredFields) {
    RequiredFields["full_name"] = "full_name";
    RequiredFields["position"] = "position";
    RequiredFields["phone_number"] = "phone_number";
})(RequiredFields = exports.RequiredFields || (exports.RequiredFields = {}));


dist/types.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getEnumVal = exports.isDomain = exports.isNumeric = exports.delay = void 0;
async function delay(ms) {
    return new Promise((r) => setTimeout(r, ms));
}
exports.delay = delay;
function isNumeric(str) {
    const parsedNr = parseFloat(str);
    return !isNaN(parsedNr) && isFinite(parsedNr);
}
exports.isNumeric = isNumeric;
function isDomain(str) {
    const domainRegex = /^(?:[-A-Za-z0-9]+\.)+[A-Za-z]{2,}$/;
    return domainRegex.test(str);
}
exports.isDomain = isDomain;
function getEnumVal(ENUM, input) {
    return Object.entries(input)
        .map(([key]) => {
        const enumVal = ENUM[key];
        return input[key] === true ? enumVal : null;
    })
        .filter((val) => val);
}
exports.getEnumVal = getEnumVal;


dist/utils.js

Hunter.io's Domain Search is a robust tool for discovering all email addresses linked to a specific domain. It offers confidence scores, department filters, and detailed sources, making it an invaluable resource for efficient contact information retrieval.

Hunter.io Domain Search

Hunter.io Domain Search · Apify

Input · Hunter.io Domain Search · Apify

API · Hunter.io Domain Search · Apify

Source code · Hunter.io Domain Search · Apify

Related Actors · Hunter.io Domain Search · Apify

Hunter.io's Domain Search is a robust tool for discovering all email addresses linked to a specific domain. It offers confidence scores, department filters, and detailed sources, making it an inval...

Where next?