# Letterboxd Email Scraper (`email_scraper/letterboxd-email-scraper`) Actor

Letterboxd Email Scraper extracts publicly indexed email addresses from Letterboxd using targeted keywords, locations, and email domains. Discover relevant film professionals, filter unwanted results, remove duplicates, and export structured leads to an Apify Dataset.

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

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

### 🔹 Letterboxd Email Scraper – Overview

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

Instead of manually searching hundreds of Letterboxd pages, you can provide a list of targeted keywords such as `Filmmaker`, `Film Director`, `Film Producer`, or `Movie Reviewer` and let the Actor process the search combinations automatically.

> **💡 What problem does it solve?**
>
> - Automates targeted Letterboxd email discovery
> - Searches using multiple keywords and email domains
> - Supports optional country, state, or city targeting
> - Removes duplicate email addresses across the run
> - Lets you exclude unwanted profile snippets using words or phrases
> - Stores discovered leads in an Apify Dataset

The Actor is particularly useful when you need structured Letterboxd contact leads for research, outreach, lead generation, prospect discovery, or market analysis based on publicly indexed information.

***

### 🔹 Letterboxd Email Scraper – Key Features

The **Letterboxd Email Scraper** combines keyword-based search with email-domain filtering so you can build more focused searches instead of relying on one broad query.

> **🚀 Key Features**
>
> - Keyword-based Letterboxd email discovery
> - Multiple search keywords in one run
> - Multiple email-domain suffixes
> - Optional location filtering
> - Exclude-word and exclude-phrase filtering
> - Duplicate email prevention
> - Structured Apify Dataset output
> - Incremental result saving
> - Resume support for interrupted runs
> - Configurable email collection limit
> - Free-tier maximum of 100 collected unique emails
> - Paid users are not restricted by the built-in 100-email free-tier ceiling

You can combine several related keywords to improve search coverage. For example, a film-focused campaign could use `Filmmaker`, `Film Director`, `Film Producer`, and `Independent Filmmaker`.

This keyword expansion approach is useful because different Letterboxd profiles can contain different professional descriptions and terminology.

***

### 🔹 Letterboxd Email Scraper – What Data Can You Extract?

The **Letterboxd Email Scraper** produces structured lead records containing the search keyword, profile or result title, description, URL, and discovered email address.

The raw dataset records contain these fields:

- **network** — Identifies the source network as Letterboxd.com.
- **keyword** — The keyword responsible for finding the result.
- **title** — The title associated with the search result.
- **description** — The publicly available search-result description used for extraction.
- **url** — The URL associated with the result.
- **email** — The email address detected according to the selected domain filters.

> **📊 Output Example**
>
> ```json
> {
>   "network": "Letterboxd.com",
>   "keyword": "Filmmaker",
>   "title": "Example Film Profile",
>   "description": "Filmmaker and director ... filmmaker@example.com",
>   "url": "https://letterboxd.com/example/",
>   "email": "filmmaker@example.com"
> }
> ```

The Dataset view is configured to display the primary lead fields in a table: `keyword`, `title`, `description`, `url`, and `email`.

This makes the output easy to inspect inside Apify and suitable for further processing using the structured dataset generated by the Actor.

***

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

Using the **Letterboxd Email Scraper** is straightforward. You only need to provide your search keywords and adjust the optional filters when necessary.

#### 🔍 Step 1: Enter Keywords

Add one or more keywords describing the type of Letterboxd profiles you want to discover.

Examples:

- `Filmmaker`
- `Film Director`
- `Film Producer`
- `Screenwriter`
- `Movie Reviewer`
- `Independent Filmmaker`

Multiple keywords can be used in the same run.

#### 📍 Step 2: Add a Location

The `location` field is optional.

You can enter a country, state, or city when you want to narrow your search geographically.

Examples:

- `United States`
- `Canada`
- `London`
- `Los Angeles`
- `New York`

Leave the field empty when you want broader search coverage.

#### 📧 Step 3: Choose Email Domains

The `customDomains` field controls which email-domain suffixes the Actor looks for.

The default value is:

```text
@gmail.com
```

You can add additional domains such as:

- `@gmail.com`
- `@yahoo.com`
- `@outlook.com`
- `@hotmail.com`
- `@icloud.com`
- A relevant company domain

Using several domain suffixes can increase coverage because different publicly listed contacts may use different email providers.

#### 🔢 Step 4: Set the Maximum Email Target

The `maxEmails` input controls how many addresses the Actor attempts to collect for each keyword and domain combination.

The allowed range is **1 to 10,000**, with a default of **10**.

For example, if you use:

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

the Actor processes the keyword/domain combinations independently and targets up to 20 addresses for each combination.

Because duplicate emails are removed globally, the final number of unique addresses can be lower than the theoretical maximum.

#### 🚫 Step 5: Add Exclude Words

Use `excludeWords` when certain words or phrases should cause a search-result snippet to be skipped.

For example:

- `crypto`
- `onlyfans`
- `adult`

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

This filter applies to the description snippet before an email is collected from that result.

***

### 🔹 How to Scrape Letterboxd Emails by Keyword

The **Letterboxd Email Scraper** is designed around targeted keyword combinations.

A broad keyword such as `Film` may produce a large and less focused search space. More descriptive searches can be useful when your goal is professional lead discovery.

For example, you could create a keyword list such as:

```text
Filmmaker
Film Director
Film Producer
Independent Filmmaker
Screenwriter
```

You can then combine those keywords with selected email domains.

> **🎯 Search Strategy**
>
> - Start with 3–5 closely related keywords.
> - Use professional titles relevant to your target audience.
> - Add several email domains when broader email coverage is required.
> - Use location only when geographic targeting is important.
> - Review initial results and broaden keywords if the result volume is low.

The Actor continues through search results until its configured stopping conditions indicate that additional pages are unlikely to provide useful new email addresses.

***

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

Yes. The optional `location` input allows you to add a geographic term to your search.

This can be useful when you are researching a particular market or professional community.

For example:

```text
Keywords:
Filmmaker
Film Director
Film Producer

Location:
Canada
```

Or:

```text
Keywords:
Independent Filmmaker
Screenwriter

Location:
Los Angeles
```

If you do not need geographic targeting, leave `location` empty to allow broader discovery.

Location filtering is a search refinement rather than a guarantee that every returned profile is physically located in that exact area.

***

### 🔹 Letterboxd Email Scraper – Use Cases

The Actor can support several practical workflows involving publicly discoverable Letterboxd contact information.

> **🎬 Film Industry Lead Generation**
>
> - Discover publicly listed emails associated with filmmakers
> - Find potential film directors and producers
> - Research independent filmmaking contacts
> - Build targeted professional prospect lists

> **🔎 Market Research**
>
> - Discover professionals associated with specific film-related keywords
> - Compare search coverage across different locations
> - Analyze publicly indexed professional descriptions
> - Organize discovered contact information into structured records

> **📣 Outreach Research**
>
> - Identify publicly listed professional email addresses
> - Filter results by selected email domains
> - Organize leads by the keyword that discovered them
> - Review source URLs before using contact information

> **🌍 Location-Based Research**
>
> - Search for film professionals in specific cities
> - Narrow searches to countries or regions
> - Compare results between different geographic markets

The Actor is intended for discovery of publicly indexed information. Users should independently ensure that their collection and use of contact information complies with applicable laws, platform policies, privacy requirements, and their intended outreach rules.

***

### 🔹 Input

The **Letterboxd Email Scraper** accepts a JSON object with the following supported inputs:

| Input           | Type    | Default                  | Purpose                                            |
| --------------- | ------- | ------------------------ | -------------------------------------------------- |
| `keywords`      | Array   | Filmmaker, Film Director | Search terms used for Letterboxd discovery         |
| `location`      | String  | Empty                    | Optional country, state, or city filter            |
| `customDomains` | Array   | `@gmail.com`             | Email-domain suffixes to search for                |
| `maxEmails`     | Integer | `10`                     | Collection target per keyword + domain combination |
| `excludeWords`  | Array   | Empty                    | Words or phrases that cause snippets to be skipped |

#### 📋 Sample Input

```json
{
  "keywords": [
    "Filmmaker",
    "Film Director",
    "Film Producer"
  ],
  "location": "Canada",
  "customDomains": [
    "@gmail.com",
    "@outlook.com",
    "@yahoo.com"
  ],
  "maxEmails": 20,
  "excludeWords": [
    "crypto"
  ]
}
```

The `keywords` field is required. The other fields can be adjusted according to your search requirements.

***

### 🔹 Output

The Actor pushes discovered results into the Apify Dataset incrementally.

#### 📦 Sample Output

```json
{
  "network": "Letterboxd.com",
  "keyword": "Film Director",
  "title": "Example Director",
  "description": "Independent film director ... director@example.com",
  "url": "https://letterboxd.com/example/",
  "email": "director@example.com"
}
```

The dataset is structured so that each discovered email is associated with the search context that produced it.

This means you can identify the keyword used, inspect the description, open the source URL, and see the extracted email address in the same record.

> **📌 Important Output Note**
>
> The Actor removes duplicate email addresses during collection. Therefore, the same publicly listed email address should not be repeatedly added as a new lead simply because it appears in multiple search results.

***

### 🔹 Letterboxd Email Scraper – Pricing and Limits

The provided Actor configuration does **not specify an Actor price**, subscription price, or per-result monetary rate, so no specific price is claimed here.

The source configuration does define a built-in free-user collection ceiling:

- Free users are limited to a maximum of **100 unique collected emails** by the Actor.
- Paid users are not restricted by this specific 100-email ceiling.
- The `maxEmails` input still controls the requested collection target.
- The configured `maxEmails` value can range from **1 to 10,000**.
- Higher targets may require more search processing and may take longer.
- A target is not a guarantee that the requested number of emails exists publicly.

> **💰 Cost Planning Tip**
>
> - Use a smaller `maxEmails` value for testing.
> - Start with a few focused keywords.
> - Expand domains when additional coverage is needed.
> - Broaden the location when results are too limited.
> - Use longer run time when performing wide searches.

***

### 🔹 Tips and Best Practices

To get better results from the **Letterboxd Email Scraper**, search strategically rather than relying on one generic keyword.

- Use several related professional keywords.
- Combine job titles with industry-specific terms.
- Test your search with a small `maxEmails` value first.
- Add multiple email domains when appropriate.
- Leave the location blank for broad discovery.
- Add a location when geographic relevance matters.
- Use `excludeWords` to remove unwanted categories.
- Review the output descriptions to understand why a result was collected.
- Use source URLs to validate leads before contacting them.
- Remember that public availability varies, so a requested target may not always be reached.

If results are sparse, broaden the search terms or remove an overly restrictive location. If results contain unwanted profiles, add carefully selected exclusion words.

***

### 🔹 Frequently Asked Questions

#### 🔍 What is a Letterboxd Email Scraper?

A **Letterboxd Email Scraper** is an automated tool that searches for publicly indexed Letterboxd results using user-defined keywords and extracts email addresses matching selected domain suffixes.

#### 🔍 How do I scrape Letterboxd emails by keyword?

Enter one or more keywords in the `keywords` field, optionally add a location and email domains, and start the Actor. The scraper processes relevant search results and stores matching email addresses in the Apify Dataset.

#### 🔍 Can I use multiple Letterboxd keywords?

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

#### 🔍 Can I search Letterboxd emails by city or country?

Yes. The optional `location` field accepts a country, state, or city and uses it to narrow the search.

#### 🔍 Can I search for Gmail and Outlook addresses together?

Yes. Add multiple domain suffixes to `customDomains`, such as `@gmail.com` and `@outlook.com`.

#### 🔍 Does the Letterboxd Email Scraper remove duplicate emails?

Yes. The Actor maintains a set of previously discovered email addresses and avoids adding the same email as a new unique result.

#### 🔍 Why did I receive fewer emails than my maxEmails value?

`maxEmails` is a target, not a guarantee. The Actor can only collect email addresses that are publicly discoverable and match your keyword, domain, and filtering criteria.

#### 🔍 What happens if my search is too narrow?

A narrow keyword, restrictive location, or limited email-domain list can reduce results. Try related keywords, broader locations, or additional domain suffixes.

#### 🔍 Can I exclude specific types of profiles?

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

#### 🔍 What format does the Actor return?

Results are stored as structured records in an Apify Dataset. The records include the keyword, title, description, URL, email, and source network information.

#### 🔍 Is the collected information guaranteed to be current?

No. The Actor works with publicly indexed information, and online profiles or publicly displayed contact details can change. Always validate important leads before using them.

***

### 🔹 Support

If you need help with the **Letterboxd Email Scraper**, have questions about the inputs or output, or want to discuss a customization, you can contact me directly.

> **📧 Support**
>
> - 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": [
    "Filmmaker",
    "Film Director"
  ],
  "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": [
        "Filmmaker",
        "Film Director"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

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

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

```

## MCP server setup

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