# G2 Email Scraper (`email_scraper/g2-email-scraper`) Actor

G2 Email Scraper finds publicly available email addresses from G2-related search results using targeted keywords, locations, custom email domains, and exclusion filters. Collect structured lead data with keyword, title, description, URL, and email.

- **URL**: https://apify.com/email\_scraper/g2-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

### 🔍 G2 Email Scraper – Overview

G2 Email Scraper helps you discover publicly displayed email addresses associated with G2 profile pages using targeted search keywords, optional locations, selected email domains, and exclusion filters. It is designed for users who need structured G2 contact data for lead research, prospecting, market research, and business intelligence.

The G2 Email Scraper turns a list of search terms into organized contact records containing the keyword used, profile title, profile description, profile URL, and discovered email address. Instead of manually reviewing search results one by one, you can provide multiple targeted queries and let the Actor collect matching email addresses into an Apify Dataset.

The easiest way to start is simple: enter several specific keywords, optionally enter a country or city, choose one or more email domain suffixes, set the maximum number of emails for each keyword and domain combination, and run the Actor.

> **💡 G2 Email Scraper at a Glance**
>
> - Search G2-related results using specific keywords or queries
> - Extract publicly visible email addresses from matching profile result descriptions
> - Filter searches by country, state, city, or other location text
> - Target email domains such as `@gmail.com`, `@yahoo.com`, or company domains
> - Exclude unwanted profiles using words or phrases
> - Store results in a structured Apify Dataset
> - Continue from persisted progress after an interrupted run
> - Produce unique email records instead of repeatedly saving the same email address

Specific search terms generally produce more relevant results than broad one-word queries. For example, instead of searching only for `Software`, you can use terms such as `Software Founder`, `B2B Software`, `Software Consultant`, or `Business Software`.

### 🔎 G2 Email Scraper – Key Features

The G2 Email Scraper combines keyword targeting, email-domain filtering, location targeting, exclusion controls, structured output, and result de-duplication into one workflow.

> **✨ Key Features**
>
> - **Keyword-based search:** Enter one or multiple keywords or search queries.
> - **Location targeting:** Narrow searches with a country, state, or city.
> - **Custom email domains:** Search for specific email suffixes such as `@gmail.com`.
> - **Per-combination limits:** Set a maximum number of emails for each keyword + domain combination.
> - **Exclude words:** Skip profile descriptions containing unwanted words or phrases.
> - **Duplicate protection:** Previously collected email addresses are tracked to prevent repeated records.
> - **Structured dataset:** Results are pushed to an Apify Dataset as they are collected.
> - **Progress persistence:** The Actor stores progress so an interrupted run can resume from its saved position.
> - **Search pagination:** The Actor can continue through multiple result pages when useful matches remain.
> - **Usage-based result events:** Collected results are pushed with the `result` charge event configured by the Actor.

The G2 Email Scraper is useful when your goal is not simply to find G2 pages, but to turn relevant search intent into structured email contact data.

### 🧩 G2 Email Scraper – What Data You Can Extract

Each collected contact is associated with the search context and the profile result from which the email was discovered. This makes the dataset more useful for later filtering, enrichment, analysis, and prospect research.

> **📦 Output Data**
>
> - **keyword** — The keyword or query used to discover the result.
> - **title** — The title associated with the matching G2 result.
> - **description** — The available profile/result description containing the discovered contact information.
> - **url** — The URL of the matching result.
> - **email** — The email address extracted from the available result content.

The output is designed to be easy to inspect inside Apify Dataset views. The URL field is stored as a link, while the keyword, title, description, and email values are presented as searchable table data.

Because the Actor extracts email addresses from publicly available result content, the amount of data available depends on what matching public results contain. A keyword may produce many pages of results but still return fewer emails when contact information is not publicly visible.

### 🎯 G2 Email Scraper – How to Use It

Using the G2 Email Scraper requires only a few configuration choices.

#### 🔹 Step 1: Add targeted keywords

Enter one or more search terms in the **Keywords or Queries** field.

Specific search intent usually works better than extremely broad terms. For example:

```text
Software Founder
Business Software
SaaS Founder
Software Consultant
B2B Software
```

You can provide multiple keywords because the Actor processes the keyword list individually.

#### 🔹 Step 2: Add a location when needed

Use the **Region / Location** field to narrow your search geographically.

Examples include:

```text
United States
New York
California
London
Canada
```

Leave the location empty when you want the search to cover results without a geographic filter.

#### 🔹 Step 3: Select email domains

The **E-mail domain suffixes** field controls which email domains the Actor looks for.

Examples:

```text
@gmail.com
@yahoo.com
@outlook.com
@hotmail.com
@company.com
```

You can provide multiple domains to expand coverage across different keyword and domain combinations.

#### 🔹 Step 4: Set the email limit

The **Max Emails** setting accepts values from **1 to 10,000** in the Actor input schema.

The limit is applied independently to each keyword + domain combination. For example, with 3 keywords, 2 domains, and a limit of 20, the Actor processes six combinations, with each combination targeting up to 20 newly discovered emails.

Actual results may be lower when suitable public matches are unavailable.

#### 🔹 Step 5: Add exclusion words

Use **Exclude words** to prevent unwanted descriptions from contributing email addresses.

For example:

```text
crypto
onlyfans
gambling
```

A single word is matched case-insensitively as a whole word, while a phrase is matched case-insensitively as a substring. When an exclusion matches a result description, that entire snippet is skipped.

#### 🔹 Step 6: Start the Actor

Run the Actor after reviewing your keyword, location, domain, maximum-result, and exclusion settings.

Collected records are pushed incrementally into the dataset, allowing results to become available during the run rather than waiting for a final batch operation.

### 🔍 How to Scrape G2 Emails with Specific Search Terms

The G2 Email Scraper works particularly well when your search terms describe the kind of people, businesses, or software-related audiences you want to research.

For example, a broad keyword such as:

```text
software
```

may be replaced with more targeted searches such as:

```text
Software Founder
SaaS Founder
Software CEO
Product Manager
Business Software
B2B SaaS
Software Consultant
Enterprise Software
CRM Software
Marketing Software
```

This search strategy helps narrow discovery toward more commercially relevant results.

You can also combine keyword targeting with domains. For example, using:

```text
SaaS Founder
Software CEO
```

alongside:

```text
@gmail.com
@outlook.com
```

creates multiple search combinations rather than one shared search target.

> **🎯 Search Quality Tip**
>
> - Use several specific keywords instead of relying on one broad term.
> - Combine related job titles, business categories, and software terms.
> - Add a location when geography matters.
> - Add additional email domains when one domain produces limited results.
> - Remove an overly restrictive location when results are sparse.

### 🌍 Can You Target a Country or City?

Yes. The G2 Email Scraper supports an optional **Region / Location** value.

You can enter a country, state, city, or another geographic phrase that makes sense for the search. The location is used to narrow the search rather than being treated as a separate output field.

For example:

```text
United States
New York
Texas
Toronto
United Kingdom
```

Geographic targeting is useful for regional prospecting and market-specific research. However, a narrow location can also reduce the number of matching results, so broader searches may be preferable when coverage is more important than geography.

### 📧 Can You Search Different Email Domains?

Yes. The Actor supports a list of custom email domain suffixes.

For example:

```text
@gmail.com
@yahoo.com
@outlook.com
@icloud.com
```

You can also use a company or organization-specific suffix when relevant, such as:

```text
@company.com
```

Each domain is processed separately with each keyword. This makes domain selection an important part of search coverage.

The Actor only extracts email addresses that match the configured domain suffixes. Therefore, changing or expanding your selected domains can materially change the resulting dataset.

### 🚫 Can You Exclude Certain Profiles?

Yes. The **Exclude words** filter is designed for this purpose.

Suppose you do not want descriptions containing:

```text
crypto
onlyfans
adult
```

The Actor skips a result when one of the configured terms appears in its description.

Single words use whole-word matching, while phrases use substring matching. Matching ignores uppercase and lowercase differences.

This is useful when a broad keyword returns mixed audiences and you want to remove clearly unwanted categories before an email is collected.

### 🧮 Understanding the G2 Email Scraper Limits

The configured `maxEmails` value is a **per keyword + domain combination** target.

For example:

| Keywords | Domains | Max Emails | Combination Targets |
| -------- | ------- | ---------: | ------------------: |
| 2        | 1       |         10 |              2 × 10 |
| 2        | 2       |         20 |              4 × 20 |
| 3        | 3       |         25 |              9 × 25 |

These figures represent the configured targets, not guaranteed final results. The Actor can only collect emails that are actually discovered in matching public result content.

The Actor can inspect many search pages, but it also has built-in stopping conditions intended to avoid continuing when new email discovery becomes inefficient. This means a requested target does not guarantee that the Actor will continue indefinitely until that number is reached.

For free users, the Actor limits the configured maximum to **100 emails per keyword + domain combination** when the requested value exceeds that amount. Paid-user behavior does not apply that 100-result configuration ceiling.

### 💰 G2 Email Scraper – Pricing

The Actor code configures `Actor.push_data()` with the charged event name **`result`** for collected records. This means result output is associated with the Actor's configured usage-based result event.

The provided Actor configuration does not specify a monetary price, so no fixed dollar amount is stated here.

> **💳 Pricing Note**
>
> - The Actor uses a `result` charge event for collected output records.
> - No fixed price is defined in the provided configuration.
> - Check the current Apify Store pricing display for the applicable rate before running a large job.

Your actual result volume depends on keyword quality, selected domains, location targeting, available public information, and the stopping conditions used during collection.

### 📊 G2 Email Scraper – Sample Input

Here is an example configuration using several targeted searches and email domains:

```json
{
  "keywords": [
    "Software Founder",
    "SaaS Founder",
    "Business Software"
  ],
  "location": "United States",
  "customDomains": [
    "@gmail.com",
    "@outlook.com",
    "@yahoo.com"
  ],
  "maxEmails": 20,
  "excludeWords": [
    "crypto",
    "onlyfans"
  ]
}
```

The Actor processes each keyword and domain combination independently while applying the selected location and exclusion rules.

### 📦 G2 Email Scraper – Sample Output

A typical dataset record follows this structure:

```json
{
  "keyword": "Software Founder",
  "title": "Example Profile",
  "description": "Example public profile description with contact@example.com",
  "url": "https://example.com/profile",
  "email": "contact@example.com"
}
```

The actual values depend on the public result content discovered during your run.

> **📌 Output Reminder**
>
> - `keyword`, `title`, `description`, `url`, and `email` are the documented dataset fields.
> - The `email` value is derived from matching public result content.
> - Empty or unavailable information may result in fewer usable records.
> - Results are written incrementally to the Apify Dataset.

### 💼 G2 Email Scraper – Use Cases

The G2 Email Scraper can support several research and lead-generation workflows where G2-related contact discovery is useful.

#### 🔹 B2B lead research

Find publicly available contact emails associated with software-related G2 search results and organize them into a structured dataset.

#### 🔹 SaaS prospecting

Use terms such as `SaaS Founder`, `Software CEO`, or `B2B SaaS` to identify potentially relevant business contacts.

#### 🔹 Market research

Collect profile titles, descriptions, URLs, keywords, and emails into one dataset for subsequent analysis.

#### 🔹 Geographic prospecting

Combine business-oriented keywords with locations such as countries, cities, or states to focus research on a selected market.

#### 🔹 Email-domain research

Compare results across personal email domains and specific business-domain suffixes.

#### 🔹 Contact-list preparation

Use the structured dataset as an input for downstream data cleaning, segmentation, qualification, or other compatible workflows.

> **🚀 Why Use This Actor**
>
> - Automates repetitive G2 contact discovery
> - Supports multiple search terms in one run
> - Gives you control over email-domain matching
> - Adds optional geographic targeting
> - Removes unwanted descriptions with exclusion filters
> - Produces structured records ready for further processing
> - Saves progress during collection so interrupted work can continue

### 💡 Tips and Best Practices

For stronger results, treat keyword design as the most important part of your setup.

Start with several specific search terms rather than a single broad keyword. Mix business roles, software categories, and related commercial terminology.

Use multiple domains when your goal is broader email coverage. A single domain can naturally limit discovery even when many relevant profiles exist.

Use location selectively. A city or country can improve geographic relevance, but removing an overly narrow location may uncover significantly more potential results.

Keep exclusion terms focused. Adding too many exclusions can remove useful profiles unintentionally.

Lower `maxEmails` when you want shorter runs or more controlled result volumes. Increase it when you want deeper discovery and are comfortable with longer runs and potentially higher usage.

The Actor also keeps track of previously collected email addresses and saves progress during processing. This helps reduce duplicate email records and provides resume support when runs are interrupted.

### ❓ Frequently Asked Questions

#### 🔹 What is the G2 Email Scraper?

G2 Email Scraper is an Apify Actor that searches for relevant G2 results and extracts publicly available email addresses matching the email domains you specify.

#### 🔹 How do I use the G2 Email Scraper?

Enter keywords, optionally add a location, select email domains, configure the maximum email target, and optionally add exclusion words before starting the run.

#### 🔹 Can G2 Email Scraper search multiple keywords?

Yes. The keywords field accepts a list, allowing multiple targeted searches in a single run.

#### 🔹 What data does the G2 Email Scraper return?

The documented dataset contains `keyword`, `title`, `description`, `url`, and `email`.

#### 🔹 Can I search G2 emails by city or country?

Yes. The optional location field can be used to narrow results by a country, state, city, or similar geographic phrase.

#### 🔹 Can I search Gmail, Yahoo, and Outlook emails?

Yes. You can provide multiple custom email-domain suffixes, including `@gmail.com`, `@yahoo.com`, and `@outlook.com`.

#### 🔹 Can I use a company email domain?

Yes. You can provide a business domain suffix such as `@company.com` when it is relevant to your search.

#### 🔹 Can I exclude specific words from G2 results?

Yes. The exclude words field can remove result descriptions containing configured words or phrases.

#### 🔹 What happens when no email is found?

The Actor continues according to its collection and stopping logic. Results may be lower than the requested target when suitable public contact information is unavailable.

#### 🔹 Is `maxEmails` a total run-wide limit?

No. The configured target is applied separately to each keyword + domain combination.

#### 🔹 Does the Actor guarantee the requested number of emails?

No. `maxEmails` defines a target or cap for processing, but the final count depends on available matching public results and the Actor's stopping conditions.

#### 🔹 Does the G2 Email Scraper avoid duplicate emails?

The Actor maintains a set of previously seen email addresses and skips emails already collected during persisted progress tracking.

#### 🔹 Can the Actor resume an interrupted run?

Yes. The Actor saves its progress and cursor information so processing can resume from the stored position.

#### 🔹 Can I use broad keywords such as “software”?

Yes, but more specific terms such as `Software Founder`, `SaaS Founder`, or `Business Software` can make the search more targeted.

### 🛠️ Tips for Better G2 Email Results

Think in terms of search coverage rather than relying on one keyword.

A useful starting structure is:

```text
3–5 related keywords
+
2–5 relevant email domains
+
optional location
+
focused exclusion words
```

For example, a B2B software research run could use:

```text
Software Founder
SaaS Founder
Business Software
B2B SaaS
Software Consultant
```

with:

```text
@gmail.com
@outlook.com
@yahoo.com
```

You can then refine the next run based on which searches produced the most useful profiles.

Remember that publicly available contact data varies significantly between search topics. Some searches may return many relevant pages but only a small number of visible email addresses.

### 📞 Support

For questions, custom requirements, improvements, or bespoke Actor development related to this scraper, you can contact the developer directly by email.

- contact me by email : <alphascraper69@gmail.com>

# 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": [
    "Software",
    "Business Software"
  ],
  "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": [
        "Software",
        "Business Software"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("email_scraper/g2-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": [
        "Software",
        "Business Software",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
    "excludeWords": [],
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,email_scraper/g2-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/Njp7oz6NS2ua8PelK/builds/a6mHseGKhoIcoUjyX/openapi.json