# ResearchGate Email Scraper (`email_scraper/researchgate-email-scraper`) Actor

ResearchGate Email Scraper — extracts publicly listed email addresses from ResearchGate-related search results using your chosen keywords, email domains, locations, and exclusion filters. Generate structured leads with keyword, title, description, URL, and email data.

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

### 🔹 ResearchGate Email Scraper – Overview

- **ResearchGate Email Scraper** is an Apify Actor designed to find publicly indexed email addresses associated with ResearchGate search results. It uses your search keywords, optional location targeting, and selected email-domain suffixes to identify relevant ResearchGate pages and extract matching email addresses from publicly available search-result descriptions.

- The **ResearchGate Email Scraper** is useful for lead research, academic contact discovery, researcher outreach, business intelligence, B2B prospecting, partnership research, and other workflows where publicly listed ResearchGate contact information is relevant.

- Instead of manually searching ResearchGate-related results one by one, you can provide multiple keywords such as `professor`, `University`, `researcher`, `biology professor`, or `machine learning`, then let the Actor process the search combinations automatically.

> 💡 **What it solves:** The ResearchGate Email Scraper turns targeted ResearchGate search queries into structured contact records containing the matching email address, result title, description, URL, and keyword used.

***

### 🔍 ResearchGate Email Scraper – Key Features

- *Keyword-based ResearchGate email extraction*
- *Search multiple keywords in one run*
- *Target specific email domains such as @gmail.com, @yahoo.com, or @outlook.com*
- *Optional country, state, city, or regional filtering*
- *Exclude unwanted words or phrases from result descriptions*
- *Configurable email collection limit*
- *Duplicate email prevention*
- *Structured dataset output*
- *Incremental result storage during the run*
- *Automatic search-result pagination*
- *Resume support for interrupted runs*
- *ResearchGate-focused search targeting*
- *Useful for academic, business, research, and outreach workflows*

The **ResearchGate Email Scraper** is especially useful when your objective is not simply to collect pages, but to identify publicly indexed contact information matching a specific research topic, professional role, location, or email domain.

> 📌 **Important:** The Actor only extracts email addresses that are publicly available in the search-result content it processes. It does not guarantee that every ResearchGate profile contains an email address.

***

### 🔹 ResearchGate Email Scraper – What Data You Can Extract

- *Keyword* — The keyword or query that produced the result.
- *Title* — The title of the indexed ResearchGate result.
- *Description* — The search-result description/snippet associated with the result.
- *URL* — The URL associated with the search result.
- *Email* — The email address matching your selected domain suffix.
- *Network* — The source network identifier, returned as `ResearchGate.com`.

The primary output is designed to be simple and useful for downstream lead processing.

| Field         | Description                                 |
| ------------- | ------------------------------------------- |
| `network`     | Identifies the source as `ResearchGate.com` |
| `keyword`     | Search keyword used for the result          |
| `title`       | Search-result title                         |
| `description` | Search-result description/snippet           |
| `url`         | Result URL                                  |
| `email`       | Extracted email address                     |

> 📦 **Output format:** Results are pushed to the Actor dataset as structured records, making them convenient to inspect and process through the Apify platform.

#### 🔹 Example Output

```json
{
  "network": "ResearchGate.com",
  "keyword": "professor",
  "title": "Professor Example - ResearchGate",
  "description": "Professor Example ... example@gmail.com ... research profile",
  "url": "https://www.researchgate.net/profile/Example",
  "email": "example@gmail.com"
}
```

The exact results depend on what is publicly indexed and returned for your selected search terms. The Actor does not invent missing information.

***

### 🔹 ResearchGate Email Scraper – How to Use It

- *Step 1:* Open the Actor and enter one or more keywords.
- *Step 2:* Optionally enter a country, city, state, or other location.
- *Step 3:* Add the email domains you want to target.
- *Step 4:* Set the maximum email target.
- *Step 5:* Optionally add exclusion words or phrases.
- *Step 6:* Start the Actor.
- *Step 7:* Review the structured ResearchGate email results in the dataset.

For better coverage, use several closely related search terms rather than relying on one broad keyword.

For example, instead of using only:

```text
Fitness
```

consider:

```text
Fitness Coach
Fitness Trainer
Fitness Researcher
Exercise Science
Sports Science Professor
```

This gives the **ResearchGate Email Scraper** several distinct search opportunities.

> 🎯 **Recommended strategy:** Combine specific professional roles, research topics, skills, industries, and geographic terms when appropriate. More targeted queries can help you discover different publicly indexed results.

***

### 🔹 ResearchGate Email Scraper – Input

The Actor accepts a JSON object with the following user-facing inputs.

#### 🔹 `keywords`

- *Type:* Array
- *Required:* Yes
- *Purpose:* ResearchGate search keywords or queries.

Example:

```json
{
  "keywords": [
    "professor",
    "University",
    "machine learning researcher"
  ]
}
```

Multiple keywords are processed individually. This makes the ResearchGate Email Scraper suitable for creating targeted search campaigns around different roles, subjects, or industries.

#### 🔹 `location`

- *Type:* String
- *Required:* No
- *Purpose:* Narrows searches using a country, state, city, or other geographic term.

Example:

```json
{
  "location": "United States"
}
```

You can also use:

```text
London
Canada
New York
Germany
Dhaka
```

Leave this field empty when you want the search to remain geographically broad.

#### 🔹 `customDomains`

- *Type:* Array
- *Required:* No
- *Default:* `@gmail.com`
- *Purpose:* Specifies email-domain suffixes that the Actor should look for.

Example:

```json
{
  "customDomains": [
    "@gmail.com",
    "@yahoo.com",
    "@outlook.com"
  ]
}
```

You can also target organization-specific domains when appropriate, such as:

```text
@university.edu
@company.com
@organization.org
```

The **ResearchGate Email Scraper** matches email addresses against the domains supplied here.

#### 🔹 `maxEmails`

- *Type:* Integer
- *Minimum:* 1
- *Maximum:* 10,000
- *Default:* 10

This controls the collection target for each keyword + domain combination.

For example, with:

```text
3 keywords
2 email domains
maxEmails = 20
```

the Actor processes six keyword/domain combinations, with a target of up to 20 newly discovered addresses for each combination.

Actual results can be lower because the Actor can only collect email addresses that are publicly indexed and successfully discovered.

#### 🔹 `excludeWords`

- *Type:* Array
- *Required:* No
- *Default:* Empty

Use this input to skip result descriptions containing unwanted words or phrases.

Example:

```json
{
  "excludeWords": [
    "crypto",
    "onlyfans"
  ]
}
```

Single words are matched as whole words, while phrases are matched as phrases. Matching is case-insensitive.

> ⚠️ **Filtering behavior:** When a result description matches an exclusion term, the complete snippet is skipped and no email is extracted from that result.

***

### 🔹 How to Scrape ResearchGate Emails by Keyword

The easiest workflow is to build a keyword matrix.

For example:

```json
{
  "keywords": [
    "Professor",
    "University Researcher",
    "AI Researcher",
    "Machine Learning Professor"
  ],
  "location": "Canada",
  "customDomains": [
    "@gmail.com",
    "@outlook.com"
  ],
  "maxEmails": 25,
  "excludeWords": []
}
```

The **ResearchGate Email Scraper** then works through the keyword and email-domain combinations and searches for relevant publicly indexed results.

This approach is useful when you want to separate different prospecting segments, such as professors, researchers, academics, consultants, or subject-matter specialists.

***

### 🔹 Can You Target Specific Email Domains?

- *Yes.* The Actor supports custom email-domain suffixes.

This is useful when your campaign needs specific types of contact information.

Examples include:

- *@gmail.com*
- *@yahoo.com*
- *@outlook.com*
- *@hotmail.com*
- *@icloud.com*
- *@university.edu*
- *@company.com*

Using several domains can increase search coverage, but it does not guarantee additional emails. Results depend on publicly indexed information.

> 💡 **Tip:** If your target audience is academic or organizational, combining common consumer domains with relevant institutional domains can make your ResearchGate email research more targeted.

***

### 🔹 ResearchGate Email Scraper – Use Cases

#### 🔹 Academic Contact Research

- *Find publicly indexed email contacts associated with professors and researchers.*
- *Build research-related contact lists.*
- *Discover academics by subject or professional role.*

#### 🔹 University Research

- *Search for university-related researchers.*
- *Target specific countries or cities.*
- *Identify publicly indexed academic contact information.*

#### 🔹 B2B Prospecting

- *Find professional contacts connected to research, technology, science, or specialist fields.*
- *Build targeted business research lists.*
- *Identify potential experts or organizational contacts.*

#### 🔹 Researcher Outreach

- *Discover publicly indexed researcher contacts.*
- *Segment searches by research topic.*
- *Use location and keyword combinations for targeted outreach research.*

#### 🔹 Lead Generation

- *Create structured contact datasets from relevant search queries.*
- *Separate leads by keyword.*
- *Filter unwanted categories using exclusion words.*

The **ResearchGate Email Scraper** is most effective when your keywords closely describe the people, research areas, or organizations you want to discover.

***

### 🔹 ResearchGate Email Scraper – Output and Dataset

Every discovered email is pushed incrementally into the Apify dataset.

The dataset view is organized around:

- *Keyword*
- *Title*
- *Description*
- *URL*
- *Email*

The Actor also includes the `network` value in the generated record to identify the source as ResearchGate.com.

Because records are pushed incrementally, results can become available during the run rather than requiring the entire search process to finish before individual records are stored.

> 📊 **Structured data:** The dataset is suitable for viewing, filtering, exporting, or using as input for additional Apify workflows.

***

### 🔹 ResearchGate Email Scraper – Duplicate Handling

The Actor maintains a set of previously discovered email addresses during its run.

If the same email address appears repeatedly across different search results, the ResearchGate Email Scraper does not push that email repeatedly as a new lead.

This is particularly useful when multiple keywords overlap.

For example, the same researcher might appear for:

```text
Professor
AI Researcher
Machine Learning
University Researcher
```

The duplicate-tracking behavior helps keep the resulting email collection cleaner.

***

### 🔹 ResearchGate Email Scraper – Search Coverage

The Actor processes search-result pages for each keyword and email-domain combination. It continues pagination while useful new results are being discovered and stops when its configured stopping conditions indicate that further searching is unlikely to produce useful additional emails.

Search coverage can vary significantly depending on:

- *Keyword specificity*
- *Location*
- *Selected email domains*
- *Public indexing*
- *Availability of email addresses*
- *Number of relevant search results*

Therefore, a requested maximum is a target rather than a guarantee.

> ⚠️ **Important:** If your run produces fewer emails than expected, broaden the keywords, add related search terms, expand or remove the location, or test additional email domains.

***

### 🔹 ResearchGate Email Scraper – Free and Paid Usage

The Actor code applies a **100-email restriction for free users** when configuring the requested maximum. Paid users do not have this specific code-level restriction.

The Actor itself does **not** define a separate monetary price in the provided configuration, so no specific dollar price is claimed here.

> 💰 **Pricing note:** Your final cost depends on the Apify platform/account pricing applicable to your usage. The Actor configuration provided does not specify a fixed Actor price.

***

### 🔹 Tips and Best Practices

- *Use multiple related keywords instead of one extremely broad keyword.*
- *Combine professional titles with research subjects.*
- *Use location only when geographic targeting is important.*
- *Remove the location filter when coverage is too narrow.*
- *Add multiple email domains when appropriate.*
- *Use exclusion words to remove irrelevant result categories.*
- *Start with a moderate `maxEmails` value and increase it when needed.*
- *Review descriptions and URLs before using collected contacts for outreach.*
- *Use publicly available information responsibly and comply with applicable privacy, data-protection, and outreach regulations.*

> 🚀 **Better search strategy:** A combination such as `Professor + Machine Learning + Canada` can be more useful for a focused campaign than a single generic query such as `Researcher`.

***

### 🔹 What Is the Best Way to Use ResearchGate Email Scraper?

The best workflow depends on your target audience, but a practical approach is to start with several highly relevant keywords, one or more suitable email domains, and no location restriction.

After reviewing the initial results, refine your search using:

- *More specific professional roles*
- *Related research topics*
- *Alternative keyword wording*
- *Additional email domains*
- *Geographic targeting*
- *Exclude words*

This iterative process can help you build a more relevant ResearchGate contact dataset without relying on a single search phrase.

***

### 🔹 Frequently Asked Questions

#### 🔹 What is ResearchGate Email Scraper?

ResearchGate Email Scraper is an Apify Actor that searches publicly indexed ResearchGate-related results using specified keywords and extracts email addresses matching the configured domain suffixes.

#### 🔹 What data does ResearchGate Email Scraper return?

The Actor returns the keyword, title, description, URL, email address, and source network identifier in its dataset records.

#### 🔹 Can ResearchGate Email Scraper search by country or city?

Yes. The optional `location` input can contain a country, state, city, or other geographic term to narrow the search.

#### 🔹 Can I use multiple keywords?

Yes. The `keywords` input accepts an array, allowing you to process multiple search terms in one run.

#### 🔹 Can I search multiple email domains?

Yes. The `customDomains` input accepts multiple domain suffixes, including common providers and relevant custom or organizational domains.

#### 🔹 Why did my ResearchGate email scraper return fewer emails than my limit?

The configured `maxEmails` value is a collection target, not a guarantee. The Actor can only extract matching email addresses that are publicly indexed and discovered through the searches. Narrow keywords, limited indexing, location filters, and duplicate results can all reduce the final count.

#### 🔹 Can I exclude unwanted ResearchGate results?

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

#### 🔹 Does the Actor remove duplicate emails?

Yes. The Actor tracks previously discovered email addresses so repeated appearances of the same address are not treated as new email results.

#### 🔹 Can I use institutional email addresses?

Yes. You can provide institutional or organization-specific domain suffixes in `customDomains`, provided those addresses are publicly indexed in the searchable result content.

#### 🔹 Does the Actor guarantee a specific number of emails?

No. Search results depend on publicly indexed information and the availability of matching email addresses. A higher target does not guarantee a larger result set.

#### 🔹 Can I use the output for another workflow?

The results are stored in an Apify dataset with structured fields, making them suitable for further processing within workflows that support Apify dataset data.

***

### 🔹 Support

- *Need help choosing keywords?*
- *Having trouble getting enough results?*
- *Want to optimize your domain combinations?*
- *Need a custom adjustment or bespoke scraper?*

For questions, improvements, or custom development requests:

**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": [
    "professor",
    "University"
  ],
  "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": [
        "professor",
        "University"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

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

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

```

## MCP server setup

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