# Kompass Email Scraper (`email_scraper/kompass-email-scraper`) Actor

Scrape publicly indexed Kompass contacts with Kompass Email Scraper. Find email addresses using targeted keywords, locations, and custom email domains, with exclude-word filtering and structured dataset output for B2B lead generation, prospecting, and market research.

- **URL**: https://apify.com/email\_scraper/kompass-email-scraper.md
- **Developed by:** [Email Scraper](https://apify.com/email_scraper) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### Kompass Email Scraper Overview

**Kompass Email Scraper** is an Apify Actor designed to find publicly published email addresses associated with Kompass.com pages through keyword-based Google search. It searches indexed Kompass results, extracts matching email addresses from search-result descriptions, and saves structured lead data to an Apify dataset.

The **Kompass Email Scraper** is useful for B2B lead generation, market research, prospect discovery, contact research, and business data collection. You can search with multiple keywords, optionally narrow results by country, state, or city, and control which email-domain suffixes should be collected.

The **Kompass Email Scraper** does not attempt to access private contact information. Email extraction is based on information exposed in publicly indexed Google search snippets for Kompass pages.

### Kompass Email Scraper Features

The **Kompass Email Scraper** provides a keyword-driven workflow designed for flexible contact discovery.

- **Keyword-based search:** Submit one or many search terms to target relevant Kompass pages.
- **Location filtering:** Add an optional country, state, or city to narrow search results.
- **Custom email domains:** Search for specific suffixes such as `@gmail.com`, `@yahoo.com`, `@outlook.com`, or business domains.
- **Per-combination email target:** The configured limit is applied independently to each keyword and email-domain combination.
- **Exclude-word filtering:** Skip a result when its description contains a configured word or phrase.
- **Duplicate prevention:** Previously collected email addresses are tracked so the same email is not repeatedly pushed.
- **Incremental dataset output:** Matching records are pushed as they are found.
- **Progress persistence:** Run progress and discovered emails are stored so processing can resume after an interruption.
- **Google SERP proxy:** Requests use the Apify `GOOGLE_SERP` proxy group with proxy rotation and retry handling.

### How to Use the Kompass Email Scraper

Using the **Kompass Email Scraper** starts with selecting search keywords that describe the businesses, professionals, industries, or services you want to discover.

For better coverage, use several specific search terms instead of relying on one broad keyword. For example, a B2B campaign could combine terms such as `Electrical Equipment`, `Cable Manufacturer`, `Industrial Cables`, or other relevant phrases.

The **Kompass Email Scraper** creates a Google query for each keyword and email-domain combination. The base search targets Kompass pages with the structure `site:kompass.com`, while the selected domain suffix is included in the search query.

When a location is provided, that location is also added to the search query. Leaving the location blank allows the search to operate without an explicit geographic phrase.

The scraper processes Google result pages sequentially. It parses organic results, reads their titles, URLs, and descriptions, then searches the descriptions for email addresses matching the configured domain suffixes.

Once an email is discovered, the **Kompass Email Scraper** checks whether it has already been seen during the run. New addresses are stored and pushed to the Apify dataset immediately.

### Kompass Email Scraper Data Extraction

The **Kompass Email Scraper** extracts contact information from Google-indexed Kompass search results rather than directly crawling private Kompass account areas.

For each eligible result, the Actor can collect the keyword used to discover the result, the result title, the search-result description, the result URL, and the matching email address.

The implementation also writes a `network` value of `Kompass.com` to each dataset record. The default dataset view focuses on `keyword`, `title`, `description`, `url`, and `email`.

Email matching is controlled by the domain suffixes provided in `customDomains`. This makes it possible to focus the collection on particular email providers or domains relevant to your prospecting workflow.

The **Kompass Email Scraper** also supports exclusion rules. When an exclude word or phrase appears in the description snippet, the complete snippet is skipped and no email from that snippet is collected.

#### Email Extraction Behavior

The email parser uses a structured pattern combining the configured domain suffixes. It searches the result description for an email local part followed by one of the selected suffixes.

This means the available email results depend on what Google exposes in its indexed Kompass snippets. A company can exist on Kompass without producing an extractable address in the returned search description.

#### Exclude Word Filtering

The `excludeWords` input can contain words or phrases such as `crypto` or `onlyfans`.

Single-word exclusions are matched as whole words and without case sensitivity. Multi-word exclusions are matched as case-insensitive phrases.

When an exclusion matches a result description, that result is ignored before email extraction. This is useful for removing irrelevant search results from a lead collection workflow.

### Kompass Email Scraper Use Cases

The **Kompass Email Scraper** can support several practical business-data workflows when the required information is publicly indexed.

#### B2B Lead Generation

Use targeted industry, service, product, or company-related keywords to discover publicly exposed email contacts associated with Kompass results.

#### Market Research

Collect structured search-result information for researching businesses, industries, product categories, and geographic markets represented in Kompass pages.

#### Prospect Discovery

Combine multiple focused keywords and optional geographic filters to identify potential organizations relevant to a sales or research campaign.

#### Business Intelligence

Export result titles, descriptions, URLs, and emails into structured datasets for analysis, segmentation, or downstream processing.

#### CRM Enrichment

The output can provide an additional publicly indexed contact signal that may be used alongside other independently obtained business data.

#### Competitive Research

Search product categories, services, or industry terms to identify relevant Kompass pages and review the associated public snippets and contact information.

### Input Parameters for the Kompass Email Scraper

The **Kompass Email Scraper** accepts the following actor inputs.

| Input           | Type             | Required | Default                              | Description                                                                                              |
| --------------- | ---------------- | -------: | ------------------------------------ | -------------------------------------------------------------------------------------------------------- |
| `keywords`      | Array of strings |      Yes | `["Electrical Equipment", "Cables"]` | Search keywords or queries used to find relevant Kompass results. Multiple values can be supplied.       |
| `location`      | String           |       No | `""`                                 | Optional country, state, or city used to narrow the Google search.                                       |
| `customDomains` | Array of strings |       No | `["@gmail.com"]`                     | Email-domain suffixes to search for, such as `@gmail.com` or `@yahoo.com`.                               |
| `maxEmails`     | Integer          |       No | `10`                                 | Maximum target for new emails collected per keyword + domain combination. Valid input range is 1–10,000. |
| `excludeWords`  | Array of strings |       No | `[]`                                 | Words or phrases that cause a matching result description to be skipped.                                 |

The **Kompass Email Scraper** requires `keywords`, while all other parameters are optional according to the actor schema.

#### Choosing Keywords

Use multiple specific queries when possible. A single generic term can produce limited or less targeted results, while related search phrases can broaden coverage.

For example, instead of one broad term such as `Fitness`, you could use more precise terms like `Fitness Equipment`, `Gym Equipment Supplier`, `Commercial Fitness Equipment`, and `Fitness Equipment Distributor`, provided those terms match your research goal.

#### Choosing a Location

The `location` field is optional. A blank value means no explicit geographic phrase is added to the search query.

Adding a country, state, or city can make a search more geographically targeted. However, a narrow location may also reduce the number of indexed results available to the **Kompass Email Scraper**.

#### Choosing Email Domains

The `customDomains` array determines which domain suffixes the Actor searches for.

You can provide consumer email suffixes or business-specific domains. Each keyword and domain pair is processed independently, giving you more control over search coverage.

#### Setting `maxEmails`

The `maxEmails` value applies to each keyword + domain combination. For example, with three keywords and two email domains, six combinations are processed independently.

The Actor schema allows values from `1` to `10000`. Free users can be capped by the Actor implementation at 100 total emails, while paid runs are not subject to that code-level free-tier ceiling.

### Output Data

The **Kompass Email Scraper** produces structured dataset records from successfully extracted results.

| Field         | Type   | Description                                                                    |
| ------------- | ------ | ------------------------------------------------------------------------------ |
| `network`     | String | Identifies the source network as `Kompass.com`.                                |
| `keyword`     | String | The keyword responsible for the search that produced the result.               |
| `title`       | String | Title of the Google organic result associated with the Kompass page.           |
| `description` | String | Parsed search-result description used for email extraction and filtering.      |
| `url`         | String | URL returned by the Google result parser.                                      |
| `email`       | String | Newly discovered email address matching one of the configured domain suffixes. |

The default Apify dataset view displays `keyword`, `title`, `description`, `url`, and `email`. Although `network` is written by the Actor, it is not included in the configured default transformation view.

In practical terms, each row connects an extracted email with the search term, source title, description snippet, and result URL that produced it. This structure makes the data suitable for review, export, filtering, and further enrichment.

### Example Input

```json
{
  "keywords": [
    "Electrical Equipment",
    "Cable Manufacturer",
    "Industrial Cables"
  ],
  "location": "Germany",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com",
    "@outlook.com"
  ],
  "maxEmails": 20,
  "excludeWords": [
    "crypto",
    "onlyfans"
  ]
}
```

This configuration creates searches across every keyword and selected email-domain combination while adding `Germany` to the query and excluding descriptions containing the configured terms.

### Example Output

```json
{
  "network": "Kompass.com",
  "keyword": "Electrical Equipment",
  "title": "Example Electrical Equipment Company | Kompass",
  "description": "Example company information ... contact@example.com ...",
  "url": "https://www.kompass.com/...",
  "email": "contact@example.com"
}
```

The exact output depends on the publicly indexed Google results returned for the selected keywords, locations, and domain suffixes.

### Data Quality and Reliability

The **Kompass Email Scraper** depends on publicly indexed Google search-result content. Consequently, the quantity and quality of extracted emails depend on what Google makes available for each query.

The Actor uses the Apify `GOOGLE_SERP` proxy group for Google requests. It can rotate the proxy URL after failed requests and retries the affected search page.

Pagination continues through Google result pages while useful results remain available. The implementation has multiple stopping conditions intended to avoid wasting requests when a query is no longer producing new emails.

These conditions include consecutive pages without new emails, consecutive empty result pages after deeper pagination, and an efficiency check for later pages that produce too few new emails.

The **Kompass Email Scraper** also maintains a persistent set of discovered email addresses. This prevents the same email from being collected repeatedly during the tracked run state.

Results are pushed incrementally to the dataset. If a dataset push encounters an error, the Actor logs the failure and continues processing rather than treating the failed push as a successful output.

### Search Intent and Practical Targeting

The **Kompass Email Scraper** is built around search intent rather than a single fixed keyword. Users can describe what they want to discover through product names, services, industries, professions, or other relevant search terms.

For high-quality lead discovery, use focused phrases that closely describe your target. Combining related terms can provide broader search coverage without relying on one overly broad query.

Location targeting can be useful when your research requires geographic segmentation. Conversely, removing the location can broaden the search when results are too sparse.

Using multiple email suffixes can also change coverage because each suffix becomes part of a separate Google search. This allows a campaign to test consumer providers and business-specific domains independently.

### Frequently Asked Questions

#### What is the Kompass Email Scraper?

The **Kompass Email Scraper** is an Apify Actor that searches Google for indexed Kompass.com pages and extracts publicly exposed email addresses matching your selected email-domain suffixes.

#### How does the Kompass Email Scraper find emails?

The Actor searches Google using queries containing `site:kompass.com`, your keyword, and a selected email-domain suffix. It then extracts matching addresses from returned result descriptions.

#### Can I search multiple keywords?

Yes. The `keywords` input accepts an array, so you can process multiple related search terms in the same run.

#### Can I target a country or city?

Yes. The optional `location` field can contain a country, state, or city. The supplied value is added to the Google query.

#### Can I choose specific email domains?

Yes. The `customDomains` input lets you specify domain suffixes such as `@gmail.com`, `@yahoo.com`, or `@outlook.com`.

#### What does `maxEmails` control?

It sets the collection target for each keyword + domain combination. It is not a single shared target across the entire keyword/domain matrix.

#### Can I exclude unwanted results?

Yes. Use `excludeWords` to skip descriptions containing selected words or phrases. Matching is case-insensitive.

#### Does the Actor collect private Kompass information?

No. The implementation extracts email addresses from information appearing in publicly indexed Google result descriptions for Kompass pages.

#### Why did my run collect fewer emails than requested?

A target is not a guarantee of available results. Google may return too few relevant pages, descriptions may not contain matching addresses, duplicate emails may already have been found, or stopping conditions may end an inefficient search.

#### Can the same email appear multiple times?

The Actor maintains a set of seen email addresses and only pushes new addresses that have not already been registered in its persisted run state.

#### Does the Kompass Email Scraper paginate through results?

Yes. The Actor processes Google result pages sequentially and stops when configured limits or its result-efficiency conditions indicate that continuing is unlikely to produce useful new emails.

#### Does the Actor use a proxy?

Yes. The implementation initializes an Apify `GOOGLE_SERP` proxy configuration and can rotate the proxy after request failures.

#### What happens if a Google request fails?

The Actor retries using a rotated proxy. Repeated hard failures can cause the current keyword/domain pair to stop processing.

#### Is there a free-user result limit?

The implementation applies a maximum of 100 collected emails for free users when the requested limit is above that ceiling or is otherwise unlimited. Paid runs do not receive that code-level free-tier restriction.

### Why Use This Actor

The **Kompass Email Scraper** combines targeted keyword search with structured extraction so you can turn publicly indexed Kompass results into an organized dataset.

Its multiple-input model makes it possible to test different product terms, services, industries, locations, and email domains within one actor run.

Incremental dataset writes mean discovered records are sent to the dataset during processing. Persistent progress tracking also records the current position in the keyword and domain workflow along with previously discovered emails.

The **Kompass Email Scraper** is therefore useful when your workflow needs repeatable search-based contact discovery rather than manually reviewing Google results one page at a time.

### API and Automation

The **Kompass Email Scraper** runs as an Apify Actor and produces results in an Apify dataset. This makes the resulting data available through the normal Apify platform workflows for actor execution, dataset handling, exports, and automation.

You can configure the Actor with your required keywords, location, email domains, maximum target, and exclusions, then run it as part of your broader data-collection process.

The implementation does not define a custom external API. Instead, it uses the standard Apify Actor execution and dataset mechanisms provided by the platform.

### Best Practices for Better Results

For the **Kompass Email Scraper**, search quality is strongly influenced by the specificity and breadth of your inputs.

Start with several closely related keywords instead of one broad term. When results are sparse, consider adding relevant variations or removing an overly restrictive location.

Likewise, adding more relevant email-domain suffixes can expand the number of keyword/domain combinations searched. Use exclusions selectively so useful results are not removed unintentionally.

Keep in mind that publicly indexed data is inherently variable. A requested target represents how many new matching emails the Actor is allowed to pursue, not a guaranteed number of contacts.

### Support

For questions, issues, or custom development related to the **Kompass Email Scraper**, use the support options available through the Actor's Apify Store page.

For bespoke changes or implementation requests, contact **<alphascraper69@gmail.com>**. When reporting an issue, include the relevant input configuration and a description of the result or error so the problem can be investigated efficiently.

# Actor input Schema

## `keywords` (type: `array`):

A list of keywords or queries to search for.

## `location` (type: `string`):

Optional country, state or city used to narrow the search. Leave it empty to search without a geographic filter.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

How many addresses each search keyword + domain suffix combination may collect before the finder moves on to the next one. This is a per-combination target, not a run-wide total: with 3 keyword and 2 Domains and a limit of 20, the run works through all 6 combinations and aims for up to 20 addresses in each, so up to 120 overall. Lower values finish sooner and cost less; higher values dig deeper but never guarantee a fuller result, since the run can only find what is publicly listed.

## `excludeWords` (type: `array`):

Words or phrases you do not want to see.

## Actor input object example

```json
{
  "keywords": [
    "Electrical Equipment",
    "Cables"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 10,
  "excludeWords": []
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "Electrical Equipment",
        "Cables"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("email_scraper/kompass-email-scraper").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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": [
        "Electrical Equipment",
        "Cables",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
    "excludeWords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("email_scraper/kompass-email-scraper").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 '{
  "keywords": [
    "Electrical Equipment",
    "Cables"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ],
  "excludeWords": []
}' |
apify call email_scraper/kompass-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,email_scraper/kompass-email-scraper"
        }
    }
}

```

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 <APIFY_API_TOKEN>` 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/R0alrs3PUAYYNyepd/builds/yzgPaL8ZbfvMLETSU/openapi.json