# Professor & Researcher Lead Finder (`crashlattice57/researcher-lead-finder`) Actor

Find verified email leads for university researchers and professors by field or conference, straight from public academic sources.

- **URL**: https://apify.com/crashlattice57/researcher-lead-finder.md
- **Developed by:** [MooreIQ](https://apify.com/crashlattice57) (community)
- **Categories:** Lead generation, Automation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $120.00 / 1,000 verified email founds

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/platform/actors/running/actors-in-store#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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Professor & Researcher Lead Finder

Professor & Researcher Lead Finder is a professor email finder for building fresh, verified researcher leads by field, conference, or journal from public academic sources.

### What it does

Enter a research topic such as `computer vision` or a venue such as `AAAI` or `Nature Methods`. The Actor finds researchers who are actively publishing in that area, ranks them by relevance, and returns structured profiles with recent work and academic affiliations. When email finding is enabled, it searches public research papers and institutional sources, verifies each discovered address, and reports its source tier and confidence. The result is a live academic prospect list rather than a stale export from a general business database.

### Who it's for

- EdTech companies and academic SaaS teams
- Lab equipment and reagent vendors
- Research-tool startups
- GPU and cloud-compute vendors targeting AI labs
- PhD and postdoc recruiters
- Academic publishers

### What you get

Each lead can include:

- **Name:** The researcher's published name.
- **Institution:** Their current or most relevant academic affiliation.
- **Country:** The institution's country.
- **ORCID:** A persistent researcher identifier when available.
- **Corresponding-author flag:** Whether the researcher is marked as a corresponding author on a matched paper.
- **Recent papers:** Relevant recent publications used to establish research activity.
- **Lead score:** A relevance and quality score from 0 to 100.
- **Tier:** A quick `hot`, `warm`, or `cool` classification based on the lead score.
- **Email:** A public professional email when one is found and passes verification.
- **Email tier:** Provenance classified as `paper-verified`, `page-found`, or `pattern-inferred`.
- **Email status:** Verification result such as `verified`, `catch-all`, or `risky`.
- **Email confidence:** The Actor's confidence in the reported email.

### How the email finding works

The Actor uses a four-stage waterfall designed for strong provenance and fewer false positives:

1. **The researcher's own recent papers:** It first extracts author emails from Europe PMC full text and open-access PDFs. This is the highest-provenance source because the address appears with the researcher's published work.
2. **Institution faculty pages:** If a paper does not expose an email, the Actor checks public university and research institution pages.
3. **A cross-run learned pattern library:** The Actor learns institution email formats across runs. The library becomes more useful and accurate as the Actor runs, helping infer likely addresses when direct sources are unavailable.
4. **Verification before delivery:** Every candidate is verified before it is reported. Results include email status, confidence, and provenance so you can judge how the address was found.

### Inputs

| Field | What it does | Default |
|---|---|---|
| `query` | Research field, conference, or journal to search, such as `AAAI`, `Nature Methods`, or `computer vision`. | Required, with `AAAI` as the Console prefill |
| `maxLeads` | Maximum number of ranked researcher leads to return. | `50` |
| `maxEmails` | Hard cap on billed emails, independent of the number of leads. `0` allows up to `maxLeads`. | `0` |
| `findEmails` | Enables public-source email discovery and verification. | `true` |
| `country` | Filters by a two-letter country code such as `US` or `GB`. Leave empty for worldwide results. | `US` |
| `yearsBack` | Limits matched papers to this many recent calendar years. | `3` |
| `correspondingOnly` | Returns only researchers marked as corresponding authors on at least one matched paper. | `false` |
| `includeIndustry` | Includes company-affiliated and other non-academic researchers. | `false` |
| `maxEmailLookups` | Caps how many leads the email waterfall attempts. `0` uses the `maxLeads` limit. This controls lookup work, not billed email successes. | `0` |
| `venueIds` | Exact OpenAlex source IDs to use instead of resolving a venue name. | `[]` |

### Pricing and controlling your spend

This Actor uses pay per event pricing, plus the platform usage for compute and proxy resources:

- **Actor start:** `$0.00005` per run.
- **`author-extracted`:** `$0.004` per lead returned.
- **`email-found`:** `$0.12` per verified email. This is the main cost. It is charged only when a real `verified` or `catch-all` email is found, so misses are free.

Use `maxLeads` to control how many researcher records are returned. Use `maxEmails` as a hard cap on how many successful email discoveries can be billed, independently of lead count. You can also set Apify's native **Max cost per run** for a hard dollar ceiling covering Actor events.

Every run logs an upfront cost estimate based on your limits and a final actual-spend summary. For example, **200 leads with `maxEmails=20` costs about `$0.80` for lead extraction plus up to `$2.40` for emails, or about `$3.20` maximum**, plus the `$0.00005` start event and your own platform compute or proxy usage.

General lead databases such as Apollo and ZoomInfo can be weak on academics because academic roles and publication activity change outside normal company datasets. This Actor builds the list live from researchers who are actually publishing, at about `$0.12` per verified email compared with roughly `$0.30` to `$1.00+` per contact elsewhere.

### Example

Input:

```json
{"query":"AAAI","maxLeads":25,"maxEmails":25}
````

Sample output row, for illustration only:

```json
{
  "name": "Dr. Maya Chen",
  "institution": "Example Institute of Technology",
  "institutionCountry": "US",
  "orcid": "0000-0002-1234-5678",
  "isCorresponding": true,
  "recentPapers": [
    {
      "title": "Reliable Planning for Multimodal Agents",
      "year": 2026,
      "venue": "AAAI"
    }
  ],
  "score": 92,
  "tier": "hot",
  "email": "maya.chen@example.edu",
  "emailTier": "paper-verified",
  "emailStatus": "verified",
  "emailConfidence": 0.98
}
```

### FAQ

#### Where does the data come from?

Researcher and publication data comes from public academic sources, including OpenAlex. Email discovery uses public Europe PMC full text, open-access papers and PDFs, and institution faculty pages.

#### Is the data public and legal to use?

The Actor searches publicly accessible academic and institutional sources. You are responsible for using the results in accordance with applicable privacy, marketing, anti-spam, and data-protection laws, as well as the terms that apply to your outreach.

#### Which conferences and journals work?

You can search by research field, conference, or journal name. Well-indexed venues such as `AAAI` and `Nature Methods` work directly, and advanced users can provide exact OpenAlex source IDs in `venueIds` when name resolution is ambiguous.

#### Why do some leads have no email?

Not every researcher publishes an address or has a discoverable faculty page. The Actor does not charge the `email-found` event for misses, and it avoids reporting candidates that do not pass verification.

#### How accurate are the emails?

Every reported email is checked before delivery and includes a verification status, confidence value, and provenance tier. Paper-extracted addresses have the strongest provenance, followed by faculty-page addresses and verified pattern-inferred addresses. `catch-all` and `risky` statuses should be handled more cautiously than `verified` results.

#### Does it support researchers outside the United States?

Yes. Set `country` to another two-letter country code or leave it empty to search worldwide. Coverage varies with publication indexing, open-access availability, and the public web presence of each institution.

# Actor input Schema

## `query` (type: `string`):

Enter a research field, conference, or journal, such as AAAI, Nature Methods, or computer vision.

## `maxLeads` (type: `integer`):

How many researcher leads to return, ranked by relevance score. Also bounds the small per-lead extraction charge. Start small (e.g. 10) to preview quality cheaply.

## `findEmails` (type: `boolean`):

Find and verify emails from public academic sources. Email enrichment is staged for a later pipeline step.

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

The main billed event is each verified email found ($ per email in this actor's pricing). This caps how many emails the run will find and bill, no matter how many leads are returned. 0 means no separate cap (up to Max leads). Example: set 10 to never pay for more than 10 emails even on a 500-lead run. You can also set Apify's own "Max cost per run" limit on the run for a hard dollar ceiling.

## `country` (type: `string`):

Target a 2-letter country code such as US or GB; leave empty to search worldwide.

## `yearsBack` (type: `integer`):

Limit papers to this many recent calendar years.

## `correspondingOnly` (type: `boolean`):

Only output researchers marked as a corresponding author on at least one matched paper.

## `includeIndustry` (type: `boolean`):

Include non-academic or company-affiliated authors; when disabled, authors with only non-education institutions are excluded.

## `maxEmailLookups` (type: `integer`):

Advanced: bounds how many leads the email finder will ATTEMPT (affects compute/proxy usage, not just billed emails). 0 = same as Max leads. Use Max emails above to cap actual email spend.

## `venueIds` (type: `array`):

Exact OpenAlex source IDs such as S4210191458; provide these to skip venue name resolution.

## Actor input object example

```json
{
  "query": "AAAI",
  "maxLeads": 5,
  "findEmails": true,
  "maxEmails": 3,
  "country": "US",
  "yearsBack": 3,
  "correspondingOnly": false,
  "includeIndustry": false,
  "maxEmailLookups": 0,
  "venueIds": []
}
```

# Actor output Schema

## `leads` (type: `string`):

Researcher leads with verified emails

# 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 = {
    "query": "AAAI",
    "maxLeads": 5,
    "maxEmails": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("crashlattice57/researcher-lead-finder").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 = {
    "query": "AAAI",
    "maxLeads": 5,
    "maxEmails": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("crashlattice57/researcher-lead-finder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "AAAI",
  "maxLeads": 5,
  "maxEmails": 3
}' |
apify call crashlattice57/researcher-lead-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crashlattice57/researcher-lead-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Professor & Researcher Lead Finder",
        "description": "Find verified email leads for university researchers and professors by field or conference, straight from public academic sources.",
        "version": "0.0",
        "x-build-id": "kSsafs9kCJdvXyVgL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crashlattice57~researcher-lead-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crashlattice57-researcher-lead-finder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crashlattice57~researcher-lead-finder/runs": {
            "post": {
                "operationId": "runs-sync-crashlattice57-researcher-lead-finder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crashlattice57~researcher-lead-finder/run-sync": {
            "post": {
                "operationId": "run-sync-crashlattice57-researcher-lead-finder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Research field or conference",
                        "type": "string",
                        "description": "Enter a research field, conference, or journal, such as AAAI, Nature Methods, or computer vision."
                    },
                    "maxLeads": {
                        "title": "Maximum leads",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "How many researcher leads to return, ranked by relevance score. Also bounds the small per-lead extraction charge. Start small (e.g. 10) to preview quality cheaply.",
                        "default": 50
                    },
                    "findEmails": {
                        "title": "Find emails",
                        "type": "boolean",
                        "description": "Find and verify emails from public academic sources. Email enrichment is staged for a later pipeline step.",
                        "default": true
                    },
                    "maxEmails": {
                        "title": "Max emails to find (spend cap)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "The main billed event is each verified email found ($ per email in this actor's pricing). This caps how many emails the run will find and bill, no matter how many leads are returned. 0 means no separate cap (up to Max leads). Example: set 10 to never pay for more than 10 emails even on a 500-lead run. You can also set Apify's own \"Max cost per run\" limit on the run for a hard dollar ceiling.",
                        "default": 0
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Target a 2-letter country code such as US or GB; leave empty to search worldwide.",
                        "default": "US"
                    },
                    "yearsBack": {
                        "title": "Years back",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Limit papers to this many recent calendar years.",
                        "default": 3
                    },
                    "correspondingOnly": {
                        "title": "Corresponding authors only",
                        "type": "boolean",
                        "description": "Only output researchers marked as a corresponding author on at least one matched paper.",
                        "default": false
                    },
                    "includeIndustry": {
                        "title": "Include industry researchers",
                        "type": "boolean",
                        "description": "Include non-academic or company-affiliated authors; when disabled, authors with only non-education institutions are excluded.",
                        "default": false
                    },
                    "maxEmailLookups": {
                        "title": "Maximum email lookups",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Advanced: bounds how many leads the email finder will ATTEMPT (affects compute/proxy usage, not just billed emails). 0 = same as Max leads. Use Max emails above to cap actual email spend.",
                        "default": 0
                    },
                    "venueIds": {
                        "title": "OpenAlex source IDs",
                        "type": "array",
                        "description": "Exact OpenAlex source IDs such as S4210191458; provide these to skip venue name resolution.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```