# Reddit Email Scraper (`solid-scraper/reddit-email-scraper`) Actor

📧 Reddit Email Scraper extracts targeted email leads from Reddit posts fast using smart filters (keywords, niches, locations). Ideal for marketers, agencies & sales teams to grow outreach lists with speed and precision 🚀—start building high-quality prospects today.

- **URL**: https://apify.com/solid-scraper/reddit-email-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 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.

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.

- **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

### Reddit Email Scraper 📬

**Reddit Email Scraper** is an Apify actor that scrapes emails from Reddit using your chosen keywords and email-domain filters. Whether you’re looking to build a **reddit leads email scraper** list, run **OSINT reddit email scraper** research, or simply **extract emails from reddit** at scale, this tool helps you turn public web discussions into usable contact data—saving you hours of manual work.

***

### 🚀 Why choose Reddit Email Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ **Keyword-driven email discovery** | Finds emails associated with Reddit bios and posts related to your keywords |
| ✅ **Custom email-domain targeting** | Helps you focus results on specific domains (for example `@gmail.com`) so your outreach stays relevant |
| ✅ **Built-in proxy support** | Supports reliable scraping runs when websites throttle or block requests |
| ✅ **Retries and fallbacks for resilience** | Includes retry logic and fallback behavior to improve the chance of successful runs |
| ✅ **Structured JSON dataset output** | Returns consistent fields like `email`, `title`, and `url` so results are easy to analyze |
| ✅ **Designed for scale with limits** | Lets you cap collection using `maxEmails` to control runtime and scraping cost |

***

### 🔑 Key features

- 🎯 **Targeted email harvesting from public sources:** Extracts emails from publicly available Reddit bios and posts tied to your keywords.
- 🧭 **Flexible discovery via keywords:** Accepts a list of keywords to broaden or narrow what the Reddit Email Scraper searches for.
- 🧩 **Email-domain filtering with customDomains:** Use `customDomains` to collect only emails matching your chosen domains.
- 🛡️ **Resilient scraping with proxy support:** Includes proxy configuration support for more reliable scraping sessions.
- 🔄 **Retries and stop conditions:** Uses retry and pagination logic, and stops when `maxEmails` is reached.
- 💾 **Real-time dataset saving:** Pushes each discovered email record to the dataset as it is found.
- 📊 **Deduplication of emails:** Avoids pushing duplicate emails across the run using `seen_emails`.
- 🔁 **Progress persistence:** Saves progress so you can resume with less risk of losing already collected data.

***

### 📝 Input

Provide input via an `input.json` file. Example structure:

```json
{
  "keywords": ["founder", "marketing"],
  "location": "",
  "platform": "Reddit",
  "customDomains": ["@gmail.com"],
  "maxEmails": 20,
  "engine": "cost-effective",
  "proxyConfiguration": {}
}
```

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `keywords` | Yes | A list of keywords to search for. These keywords drive which Reddit bios and posts are considered for email discovery. |
| `location` | No | Location to filter search results. Leave empty for no location filtering. |
| `platform` | No | Platform selector. This actor supports `Reddit` (default: `Reddit`). |
| `customDomains` | No | List of custom email domains to target (for example `@gmail.com`). Emails are filtered to match these domains. |
| `maxEmails` | No | Maximum number of emails to collect. The scraper stops once this limit is reached (default: `20`, allowed range: `1` to `10000`). |
| `engine` | No | Choose scraping engine: `cost-effective` (Cost Effective (New)) or `legacy` (Legacy). Use `cost-effective` by default. |
| `proxyConfiguration` | No | Proxy configuration for this Actor. You can configure proxies using Apify’s proxy input options. |

***

### 📦 Output

The actor saves each discovered email record to the dataset in JSON format using `Actor.pushData()`.

Example output record:

```json
{
  "network": "Reddit.com",
  "keyword": "marketing",
  "title": "No data",
  "description": "No data",
  "url": "No URL",
  "email": "example@gmail.com",
  "proxyGroups": ["cost-effective"]
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `network` | string | Source network label (`Reddit.com`). |
| `keyword` | string | The keyword currently being used for the scrape. |
| `title` | string | The title of the web result being processed. |
| `description` | string | The description/snippet text where the email was found. |
| `url` | string | The URL associated with the extracted email (the result link). |
| `email` | string | The extracted email address. |
| `proxyGroups` | array | Proxy group identifiers used for this run (as provided by the engine/proxy configuration). |

Notes:

- The actor deduplicates emails using a `seen_emails` set before pushing them to the dataset.
- Each pushed record is written immediately (so you can inspect partial progress while the run is still executing).

***

### 🚀 How to use Reddit Email Scraper (via Apify Console)

1. **Open Apify Console** 🔐\
   Log in at [console.apify.com](https://console.apify.com) and go to the **Actors** tab.

2. **Find Reddit Email Scraper**\
   Search for **Reddit Email Scraper** and open the actor page.

3. **Set your input parameters** ⚙️\
   In the **INPUT** panel, provide:
   - `keywords` (required)
   - optional filters like `customDomains` (recommended for tighter results)
   - optional limits like `maxEmails`

4. **Choose proxy options (optional but recommended for scale)** 🛡️\
   Configure `proxyConfiguration` if you have specific proxy needs for your scraping run.

5. **(Optional) Select the engine**\
   Keep the default `engine` as `cost-effective`, or switch to `legacy` if you specifically need it.

6. **Run the actor** ▶️\
   Click **Run**. During execution, you’ll see logs while the actor paginates through results and pushes records to the dataset as it finds new emails.

7. **Review results in the Dataset** 📊\
   After the run completes (or while it’s running), open the **OUTPUT** tab and inspect the dataset.

8. **Export your data**\
   Export the dataset in your preferred format (for example JSON/CSV) from the dataset UI.

No coding required—get structured **reddit email scraper** results in minutes.

***

### ⚙️ Advanced features & SEO optimization

- 🔍 **Engineered for email harvesting from Reddit bios and posts:** The Reddit Email Scraper is designed to excel at “scrape emails from reddit” and “reddit leads email scraper” workflows.
- 🧱 **Keyword + domain targeting:** Use `keywords` plus `customDomains` to narrow down results, which improves relevance for your **reddit email outreach list**.
- 🕒 **Timeout and scale awareness:** Large searches or high `maxEmails` can take longer; plan accordingly and increase run timeout settings in Run Options if needed.
- 💾 **Progress persistence for long runs:** The actor persistently saves progress (cursor and already seen emails), helping you avoid unnecessary rework during extended runs.

***

### 🎯 Best use cases

- 📈 **Growth teams building outreach lists:** Generate a starting dataset of emails connected to relevant Reddit discussions for faster lead sourcing.
- 🧠 **Market researchers analyzing community niches:** Identify contact domains tied to keywords and community themes for targeted analysis.
- 🎓 **Recruiters sourcing talent signals:** Use targeted keywords and domains to build candidate outreach lists from public profile content.
- 🏢 **B2B marketers running lead-gen campaigns:** Collect domain-filtered emails to feed email marketing workflows and CRM enrichment.
- 🧾 **Data analysts creating contact-enriched datasets:** Combine `keyword`, `title`, `url`, and `email` fields into clean tables for downstream modeling.
- 🛠️ **Developers automating OSINT pipelines:** Pull dataset output into scripts and automation systems for repeatable **reddit email list scraper** runs.
- ✉️ **Sales ops streamlining prospecting research:** Quickly compile prospects associated with specific topics and email domains.

***

### 🔧 Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array of strings
  - ✅ `customDomains` as an array of email-domain strings (e.g. `@gmail.com`)
  - ✅ `platform` supports `Reddit`

- **Proxy Support**
  - ✅ Supported via `proxyConfiguration`
  - ✅ Engine selection available via `engine` (`cost-effective` or `legacy`)

- **Retry Mechanism**
  - ✅ Built with retries and fallback behavior
  - ✅ Stops when `maxEmails` is reached

- **Dataset Structure**
  - ✅ JSON records pushed via `Actor.pushData()` with fields:
    `network`, `keyword`, `title`, `description`, `url`, `email`, `proxyGroups`

- **Rate Limits & Performance**
  - ✅ Paginates through results and supports higher limits with longer runtimes
  - ✅ Designed to keep saving progress as it finds new emails

- **Limitations**
  - ❌ Only uses emails discoverable from publicly available sources and associated content
  - ❌ Does not guarantee finding the exact number requested—use `maxEmails` as a cap, not a promise of results volume

***

### ❓ FAQ

#### ✅ What does Reddit Email Scraper do?

Reddit Email Scraper extracts email addresses from publicly available sources related to Reddit profiles, using the keywords you provide and filtering by your chosen `customDomains`.

#### ❓ How does the tool decide which emails to collect?

It uses your `keywords` to guide discovery and then extracts email addresses found in the associated Reddit bios/posts content, matching them against the email-domain filters you provide in `customDomains`.

#### ❌ Do I need to specify every input field?

No. Only `keywords` is required. You can optionally add `customDomains`, `location`, `maxEmails`, and `proxyConfiguration` depending on how targeted you want the output to be.

#### 💡 Can I limit how many emails I collect?

Yes. Use `maxEmails` to cap the maximum number of emails the actor will collect before stopping.

#### 💻 Can I use this from an API or code workflow?

Yes. This is an Apify actor, so you can run it through Apify’s platform workflows and read the dataset output. The actor pushes structured JSON records with fields like `email`, `url`, and `keyword`.

#### 🌐 What platforms are supported?

This actor is configured with `platform` set to `Reddit`.

#### ⚖️ Is this for legal/ethical use?

✅ The actor collects information from **publicly accessible sources**. It’s your responsibility to follow applicable laws and platform policies, including GDPR/CCPA and spam regulations.

#### 🧹 How do I request data removal?

For data removal requests, contact <dataforleads@gmail.com>.

***

### 🤝 Support & feature requests

Have questions about Reddit Email Scraper or want to improve your **reddit email scraper** results? We’d love to hear from you.

- 💡 **Feature Requests:** Want enhancements like additional export formats, more control over filtering, or output adjustments? Tell us what would help your **bulk email extraction from reddit** workflow.
- 📧 **Contact:** Reach out at <dataforleads@gmail.com>.

Your feedback helps shape future improvements to Reddit Email Scraper.

***

### 🧾 Closing CTA / Final thoughts

*If you need a reliable, SEO-friendly way to run a Reddit email outreach list workflow, Reddit Email Scraper is built for that—using structured output and practical controls for scale.*

# Actor input Schema

## `keywords` (type: `array`):

A list of keywords to search for.

## `location` (type: `string`):

Location to filter search results.

## `platform` (type: `string`):

Select platform.

## `customDomains` (type: `array`):

List of custom email domains

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

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

## `proxyConfiguration` (type: `object`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "",
  "platform": "Reddit",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "cost-effective"
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/reddit-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": [
        "founder",
        "marketing",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/reddit-email-scraper").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 '{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ]
}' |
apify call solid-scraper/reddit-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solid-scraper/reddit-email-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/fYxaNm8PLoVpUzvQf/builds/5LFbAd57uVyKA1dnL/openapi.json