# Rotten Tomatoes Email Scraper (`email_scraper/rotten-tomatoes-email-scraper`) Actor

Rotten Tomatoes Email Scraper finds publicly indexed Rotten Tomatoes contact emails using targeted keywords, locations, and custom email domains. Extract structured lead data with titles, descriptions, URLs, and emails for entertainment research, prospecting, and outreach.

- **URL**: https://apify.com/email\_scraper/rotten-tomatoes-email-scraper.md
- **Developed by:** [Email Scraper](https://apify.com/email_scraper) (community)
- **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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### 🔍 Rotten Tomatoes Email Scraper – Overview

**Rotten Tomatoes Email Scraper** is an Apify Actor designed to discover publicly indexed email addresses associated with Rotten Tomatoes search results using targeted keywords and email domains.

Instead of manually searching through large numbers of search results, the Rotten Tomatoes Email Scraper lets you provide terms such as `Director`, `Actor`, `Producer`, or other relevant queries and automatically searches for matching Rotten Tomatoes results where selected email addresses are publicly visible in search snippets.

The Actor returns structured lead information including the keyword used, result title, description, URL, and extracted email address. This makes the output useful for audience research, entertainment-industry prospecting, creator discovery, outreach research, and contact-data collection.

> 💡 **What it does:** Search publicly indexed Rotten Tomatoes results → identify matching email addresses → filter unwanted snippets → remove duplicate emails → save structured leads to an Apify Dataset.

The easiest way to use the Rotten Tomatoes Email Scraper is to enter several specific keywords, choose one or more email domains, optionally specify a location, and set the desired email limit for each keyword + domain combination.

***

### 🔹 Rotten Tomatoes Email Scraper – Key Features

The Actor focuses on targeted email discovery rather than collecting unrelated Rotten Tomatoes data. Its search configuration lets you control which types of contacts you want to discover.

> **✨ Key Features**
>
> - 🔎 Keyword-based Rotten Tomatoes search
> - 📧 Email extraction from publicly indexed search snippets
> - 🌎 Optional country, state, or city targeting
> - 📩 Custom email-domain filtering
> - 🚫 Exclude-word and phrase filtering
> - ♻️ Duplicate email prevention
> - 📊 Structured Apify Dataset output
> - 🔄 Incremental result storage
> - 🎯 Separate email target for every keyword + domain combination
> - ⏯️ Progress persistence for interrupted runs

#### 🎯 Targeted Keyword Search

You can provide multiple search keywords or queries in a single run.

For example, instead of using only `Actor`, you can use more specific terms such as:

- Actor
- Film Actor
- Movie Director
- Film Producer
- Casting Director
- Entertainment Producer

More specific search intent can help you target different types of Rotten Tomatoes-related results.

#### 📧 Custom Email Domains

The Rotten Tomatoes Email Scraper allows you to specify the email domains you want to search for.

Examples include:

- `@gmail.com`
- `@yahoo.com`
- `@outlook.com`
- `@hotmail.com`
- `@icloud.com`
- Custom business domains

The Actor searches each selected keyword and domain combination independently.

#### 🌎 Location-Based Search

The optional `location` input lets you add a country, state, or city to the search.

For example:

- New York
- Los Angeles
- London
- Toronto
- California
- United States

Leaving the location field empty allows the search to run without a geographic filter.

***

### 🔹 Rotten Tomatoes Email Scraper – What Data You Can Extract

The Rotten Tomatoes Email Scraper produces structured records containing the search context and information associated with each matching search result.

The primary dataset fields are:

| Field         | Description                                          |
| ------------- | ---------------------------------------------------- |
| `keyword`     | Keyword or query responsible for finding the result  |
| `title`       | Title of the search result                           |
| `description` | Search-result description or snippet                 |
| `url`         | URL associated with the search result                |
| `email`       | Email address extracted from the result              |
| `network`     | Identifies the source network as Rotten Tomatoes.com |

The default Apify Dataset table displays `keyword`, `title`, `description`, `url`, and `email`. The `network` value is included in the underlying output record.

> 📦 **Output Summary**
>
> The Actor does not simply return an email list. Each email is associated with its keyword, search-result title, description, and URL so you have useful context for evaluating the lead.

#### 📋 Sample Output

A typical dataset record has the following structure:

```json
{
  "network": "Rotten Tomatoes.com",
  "keyword": "Director",
  "title": "Example Rotten Tomatoes Result",
  "description": "Example publicly indexed result containing contact@example.com",
  "url": "https://www.rottentomatoes.com/...",
  "email": "contact@example.com"
}
```

The exact title, description, URL, and email depend on the publicly indexed search results available for the keywords and domains you provide.

***

### 🔹 Rotten Tomatoes Email Scraper – How to Use It

Using the Rotten Tomatoes Email Scraper requires only a few configuration steps.

#### 1. 🔎 Enter Your Keywords

Add one or more keywords that represent the type of contacts you want to research.

For example:

```json
{
  "keywords": [
    "Director",
    "Actor",
    "Film Producer",
    "Casting Director"
  ]
}
```

Specific keywords generally provide more focused search intent than extremely broad terms.

#### 2. 📍 Add an Optional Location

If you want to narrow the search geographically, enter a country, state, or city.

For example:

```text
Los Angeles
```

You can also leave this field empty when geographic targeting is not required.

#### 3. 📧 Select Email Domains

Specify the domains you want the Actor to look for.

Example:

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

#### 4. 🔢 Set the Email Limit

`maxEmails` controls how many addresses the Actor aims to collect for each keyword + domain combination.

For example, with:

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

there are 6 keyword/domain combinations, with a target of up to 20 addresses for each combination.

That means the theoretical target can be up to **120 addresses**, subject to the availability of publicly indexed results and duplicate filtering.

#### 5. 🚫 Add Exclude Words if Needed

Use `excludeWords` when you want to skip search-result snippets containing particular words or phrases.

For example:

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

If an excluded term appears in a result description, that complete snippet is skipped and no email is extracted from it.

***

### 🔹 How to Scrape Rotten Tomatoes Emails by Keyword

The Rotten Tomatoes Email Scraper is designed around keyword-driven search intent.

For example, a movie-industry researcher could search for:

- Director
- Actor
- Producer
- Film Producer
- Casting Director
- Movie Producer
- Entertainment Director
- Film Industry

You can combine these with email domains to create multiple targeted search combinations.

This approach is useful when your goal is to discover publicly indexed contact emails associated with particular professional or entertainment-related search terms rather than collecting a broad, undifferentiated dataset.

> 💡 **Search Tip:** If a keyword produces sparse results, try related professional terms instead of increasing the email limit alone.

***

### 🔹 Can You Find Rotten Tomatoes Producer Emails?

Yes, the Actor can search for publicly indexed email addresses associated with results matching terms such as `Producer`, `Film Producer`, or other relevant producer-related queries.

For example:

```json
{
  "keywords": [
    "Producer",
    "Film Producer",
    "Movie Producer"
  ],
  "customDomains": [
    "@gmail.com",
    "@outlook.com"
  ],
  "maxEmails": 20
}
```

The available results depend on what is publicly indexed and what email addresses appear in the relevant search-result descriptions.

The Rotten Tomatoes Email Scraper does not guarantee that every Rotten Tomatoes professional has a publicly discoverable email address.

***

### 🔹 Can You Target Rotten Tomatoes Contacts by City or Country?

Yes. The optional `location` field can be used to add a geographic term to the search.

For example:

```json
{
  "keywords": [
    "Director",
    "Actor"
  ],
  "location": "Los Angeles"
}
```

You can replace `Los Angeles` with another city, state, or country.

Location targeting can help narrow search intent when you are researching entertainment contacts within a particular market.

For broader discovery, simply leave the location field blank.

***

### 🔹 Rotten Tomatoes Email Scraper – Use Cases

The Actor can support several research and prospecting workflows where publicly indexed contact information is relevant.

> **🎬 Use Cases**
>
> - 🎥 Film and entertainment industry research
> - 🎭 Actor and director discovery
> - 🎬 Producer prospecting
> - 📧 Public contact-email research
> - 🤝 Creator partnership research
> - 📣 Entertainment marketing research
> - 🔎 Audience and professional research
> - 🌎 Location-specific contact discovery
> - 🧩 Keyword-based lead generation
> - 📊 Building structured research datasets

#### 🎥 Film Industry Research

Researchers can search professional terms such as `Director`, `Actor`, `Producer`, or `Casting Director` and organize the resulting contact information into a structured dataset.

#### 📣 Entertainment Marketing

Marketing teams can use targeted search terms to research publicly indexed contact information relevant to entertainment campaigns, partnerships, or promotional research.

#### 🤝 Professional Prospecting

The structured output makes it easier to review discovered emails alongside their associated search-result title, description, URL, and keyword.

#### 🌎 Geographic Research

Adding a location can help researchers focus their search around specific entertainment markets or geographic areas.

***

### 🔹 Rotten Tomatoes Email Scraper – Input

The Actor accepts the following user-facing inputs.

| Input           | Type    | Required | Default             |
| --------------- | ------- | -------: | ------------------- |
| `keywords`      | Array   |      Yes | `Director`, `Actor` |
| `location`      | String  |       No | Empty               |
| `customDomains` | Array   |       No | `@gmail.com`        |
| `maxEmails`     | Integer |       No | `5`                 |
| `excludeWords`  | Array   |       No | Empty               |

#### 🔎 Keywords or Queries

A required list of search terms.

Example:

```json
{
  "keywords": [
    "Director",
    "Actor",
    "Producer"
  ]
}
```

#### 📍 Region / Location

An optional country, state, or city used to narrow the search.

```json
{
  "location": "New York"
}
```

#### 📧 E-mail Domain Suffixes

A list of email-domain suffixes to search for.

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

#### 🔢 Maximum Emails

An integer from **1 to 10,000**.

The default is `5`.

The limit applies independently to each keyword + domain combination.

#### 🚫 Exclude Words

An optional list of words or phrases.

Single-word matching is case-insensitive and uses whole-word matching. Multi-word phrases are matched as phrases.

***

### 🔹 Rotten Tomatoes Email Scraper – Output

Every collected email is pushed into the Apify Dataset with contextual information.

> **📊 Output Fields**
>
> - `network` — Source network identifier
> - `keyword` — Search keyword
> - `title` — Search-result title
> - `description` — Search-result description/snippet
> - `url` — Search-result URL
> - `email` — Extracted email address

The default dataset view is configured as **Scraped Leads**, with the main table showing keyword, title, description, URL, and email.

This structure makes the data easier to review, filter, and use in downstream research workflows.

***

### 🔹 Rotten Tomatoes Email Scraper – Pricing and Limits

The Actor does not define a fixed monetary price in its configuration. The practical result limit depends on the `maxEmails` setting and the plan tier.

> **💰 Pricing / Limit Behavior**
>
> - `maxEmails` supports values from 1 to 10,000.
> - The default `maxEmails` value is 5.
> - On the free tier, the requested limit is capped at 100 emails per keyword + domain combination.
> - Paid users are not subject to this specific free-tier ceiling.
> - Higher limits do not guarantee more results because the Actor can only collect publicly indexed email addresses that match the search.
> - Using more keywords and domains creates more search combinations and can increase the potential coverage.

The actual number of returned emails can therefore be lower than the configured target.

***

### 🔹 Rotten Tomatoes Email Scraper – Tips and Best Practices

#### 🎯 Use Specific Keywords

Specific professional terms can produce more targeted results than broad keywords.

Instead of:

```text
Entertainment
```

consider terms such as:

- Film Director
- Movie Director
- Film Producer
- Casting Director
- Actor
- Film Actor

#### 📧 Use Multiple Domains

If you only search for one email provider, you may miss publicly indexed addresses using other domains.

Consider combinations such as:

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

You can also provide relevant company domains.

#### 🌎 Broaden Sparse Searches

If a run returns fewer emails than expected, the search may simply have limited publicly indexed information.

Try:

- Adding related keywords
- Removing an overly restrictive location
- Adding additional email domains
- Using broader geographic terms
- Increasing `maxEmails`

#### 🚫 Use Exclusions Carefully

Exclude words are applied to the complete search-result description.

If a snippet contains an excluded word, the entire snippet is skipped. Therefore, avoid exclusion terms that are likely to appear naturally in useful results.

#### ⏱️ Allow Enough Runtime

Wide searches can take longer because multiple keyword and email-domain combinations may require additional search-result pages.

The configured default run timeout is **3600 seconds**. If a particularly broad run requires more time, the timeout can be increased through the Apify Run options.

***

### 🔹 Does Rotten Tomatoes Email Scraper Remove Duplicate Emails?

Yes.

The Actor keeps track of already discovered email addresses and avoids registering the same email more than once during the run.

This provides cleaner lead data when the same email appears across multiple search results or keyword combinations.

Duplicate prevention is particularly useful when running several related keywords, because overlapping search results can otherwise produce repeated contact addresses.

***

### 🔹 What Happens When Search Results Are Sparse?

A low result count does not necessarily indicate a problem with the Actor.

The Rotten Tomatoes Email Scraper can only extract email addresses that are publicly visible in the indexed search-result information and match the selected email domains.

If results are limited, try:

- Using more specific but related keywords
- Adding additional email domains
- Removing the location filter
- Using a broader location
- Increasing the `maxEmails` target

More requested emails cannot create information that is not publicly indexed.

***

### 🔹 Frequently Asked Questions

#### 🔍 What is Rotten Tomatoes Email Scraper?

Rotten Tomatoes Email Scraper is an Apify Actor that searches publicly indexed Rotten Tomatoes results using specified keywords and email domains, then extracts matching email addresses with related result information.

#### 📧 How do I scrape Rotten Tomatoes emails by keyword?

Enter one or more terms in `keywords`, select your desired `customDomains`, optionally add a location, and configure `maxEmails`. The Actor searches the keyword/domain combinations and stores matching email records in the dataset.

#### 🎬 Can I find Rotten Tomatoes actor emails?

You can search using keywords such as `Actor`, `Film Actor`, or related terms. Results depend on whether matching email addresses are publicly indexed in the relevant search-result descriptions.

#### 🎥 Can I find Rotten Tomatoes director emails?

Yes, you can use terms such as `Director`, `Film Director`, or `Movie Director` as search keywords. The Actor returns matching publicly indexed email addresses when available.

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

Yes. `customDomains` accepts multiple email-domain suffixes, allowing separate searches for domains such as Gmail, Yahoo, Outlook, or relevant custom domains.

#### 🌎 Can I search Rotten Tomatoes contacts by location?

Yes. Enter a country, state, or city in the `location` field to narrow the search geographically. Leave it blank for an unrestricted geographic search.

#### 🚫 How does the Rotten Tomatoes exclude-word filter work?

If an excluded word or phrase appears in a search-result description, the entire snippet is skipped. Single words are matched case-insensitively as whole words, while phrases are matched as phrases.

#### 📊 What data does Rotten Tomatoes Email Scraper extract?

The dataset contains `network`, `keyword`, `title`, `description`, `url`, and `email`. The default dataset table displays the keyword, title, description, URL, and email fields.

#### 🔢 Is maxEmails a total run limit?

No. The configured target applies separately to each keyword + email-domain combination. For example, three keywords and two domains create six independent combinations.

#### ♻️ Does the Actor collect duplicate emails?

No. Previously discovered email addresses are tracked so the same email is not registered repeatedly during the run.

#### ⏱️ Why did my Actor return fewer emails than requested?

The target is not a guarantee. Search results may contain fewer publicly indexed emails than requested, or filtering and duplicate prevention may reduce the final count.

#### 💰 What is the free-tier email limit?

For free-tier runs, the Actor caps the requested maximum at 100 emails per keyword + domain combination. Paid users do not have this particular free-tier ceiling.

***

### 🔹 Important Notes

> ⚠️ **Please keep these limitations in mind**
>
> - The Actor relies on publicly indexed search-result information.
> - An email address is only returned when it matches one of the configured domain suffixes.
> - `maxEmails` is a target, not a guarantee of available data.
> - Location filtering can reduce the number of matching results.
> - Exclude words can intentionally remove otherwise matching snippets.
> - Duplicate emails are filtered from the collected dataset.
> - Broad searches can require more runtime.
> - Use collected contact information responsibly and comply with applicable privacy, anti-spam, and platform rules.

The Rotten Tomatoes Email Scraper is most effective when your search strategy matches the type of contacts you actually want to research.

***

### 🔹 Support

For questions, improvements, custom requirements, or Actor-related assistance, you can contact me 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": [
    "Director",
    "Actor"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 5,
  "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": [
        "Director",
        "Actor"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

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

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

```

## MCP server setup

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