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

📧 Reddit Email Scraper extracts email addresses from Reddit posts & comments fast and accurately. Great for lead gen, outreach, and market research. Save time, boost targeting, and improve campaign results. 🚀

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

## Pricing

from $1.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 🚀 — Extract Emails from Public Reddit Bios and Posts

Manually visiting profiles to collect emails wastes hours you don’t have. **Reddit Email Scraper** helps you collect email addresses from publicly available Reddit bios and posts using your keywords and optional custom domains. With the Reddit Email Scraper (including a reddit email harvesting tool style workflow), it’s ideal for marketers, recruiters, and growth teams who need contact data fast—often from thousands of pages in a single run.

***

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "network": "Reddit.com",
  "keyword": "marketing",
  "title": "Marketing-focused founder sharing resources",
  "description": "We help teams scale growth. Contact us at hello@gmail.com for partnerships.",
  "url": "https://www.reddit.com/r/example/comments/abcd1234/marketing_focused_founder_sharing_resources/",
  "email": "hello@gmail.com",
  "proxyGroups": ["cost-effective", "legacy"]
}
```

Output Fields:

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | The source network label for the lead record (`Reddit.com`) |
| `keyword` | string | Which keyword produced the email hit |
| `title` | string | The page result title associated with the extracted email |
| `description` | string | The result text where the email was found (useful for context) |
| `url` | string | The source page URL where the email appeared publicly |
| `email` | string | The extracted email address that matches your domain filters |
| `proxyGroups` | array | The proxy configuration value(s) used for the run (useful for auditing runs) |
| `error_message` | n/a | Not produced by this actor’s `push_data` output (no `error_message` field is pushed) |
| `status` | n/a | Not produced by this actor’s `push_data` output (no `status` field is pushed) |
| `success` | n/a | Not produced by this actor’s `push_data` output (no `success` field is pushed) |
| `timestamp` | n/a | Not produced by this actor’s `push_data` output (no `timestamp` field is pushed) |
| `cursor` | n/a | Not exposed in dataset output (saved only in the actor key-value store for progress) |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Reddit Email Scraper?

There are a lot of ways to pull data from Reddit — here’s what sets Reddit Email Scraper apart.

#### Keyword-driven email harvesting for outreach

You provide `keywords` (plus optional `customDomains`), and the actor extracts email addresses from publicly available Reddit content that relates to your terms—so your reddit lead generation email scraper output is aligned to your targeting.

#### Built-in domain filtering for cleaner leads

By using `customDomains` (for example `@gmail.com`), the scraper limits which email addresses it will accept, helping you focus your reddit user contact scraper results on the domains that matter for your campaigns.

#### Resilient pagination and run stability

The actor includes logic to handle empty or blocked pages and continues working through results where possible. This helps make your bulk reddit email extraction runs more dependable when working at scale.

#### Consistent, integration-ready dataset records

Each extracted lead is written to the dataset immediately using a consistent JSON shape, making this reddit email scraper software easy to pipe into analysis workflows and CRMs without manual cleanup.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

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

Input Parameters:

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords to search for (this drives what Reddit content is considered) |
| `location` | ⬜ | Location to filter search results (leave empty for no location filter) |
| `platform` | ⬜ | Select platform (currently supports `Reddit`) |
| `customDomains` | ⬜ | List of custom email domains to target (for example `@gmail.com`) |
| `maxEmails` | ⬜ | Maximum number of emails to collect; the scraper stops once this limit is reached |
| `engine` | ⬜ | Choose scraping engine: `cost-effective` (Cost Effective (New)) or `legacy` (Legacy) |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor run |

***

### Core Capabilities

#### Keyword and domain targeting

Reddit Email Scraper uses your `keywords` to find relevant Reddit content and extracts emails that match your `customDomains`. This is the core workflow behind a reddit email harvesting tool approach for outreach and list building.

#### Flexible filtering via inputs

You can narrow results with `location` and focus email collection using `customDomains`. If you want controlled scaling, set `maxEmails` so runs stop after collecting enough results for your current campaign.

#### Resilient scraping with retries and fallbacks

The actor is designed to keep going even when pages return empty results or access is temporarily blocked. For longer jobs, it also acknowledges that large searches or high email limits may take longer.

#### Real-time dataset writing

As emails are found, the actor pushes each record into your Apify dataset immediately. That means you can monitor progress and avoid losing already-collected data if you stop the run.

#### Structured output for fast downstream use

Every dataset record includes fields like `network`, `keyword`, `title`, `description`, `url`, and `email`. That makes this reddit contact list scraper well-suited for analysis pipelines and email list builder workflows.

***

### Who Gets the Most Out of This

Here's how different teams put Reddit Email Scraper to work:

**Sales and Outreach Teams** — Use it to build targeted prospect lists by focusing on the keywords that match your ICP, then extracting emails limited to your preferred domains. You end up with a usable starter list for outreach without manually digging through posts.

**Recruiters and Talent Scouts** — Run keyword-focused queries to find relevant public profiles discussing roles, companies, or specialties, then extract emails from those public bios/posts. This helps recruiters move from discovery to contact faster.

**Growth Marketers** — Combine `keywords` with domain filters (`customDomains`) to assemble a lead batch for partnerships, co-marketing, or contributor programs. The result is aligned to campaign targeting instead of a generic reddit account email lookup.

**Freelance Researchers** — Use this actor as a repeatable reddit dm email extraction and extraction step for research datasets derived from publicly available Reddit content. It’s especially helpful when you need bulk reddit email harvesting for a report or screening workflow.

**Automation & Data Engineering Specialists** — Integrate the actor run into a pipeline that ingests dataset rows into your storage layer. With consistent output fields, this reddit email scraper can serve as a dependable upstream stage for automation and analytics.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Reddit Email Scraper from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find *Reddit Email Scraper*.
2. **Enter your inputs** — add your `keywords` (required), then optionally set `customDomains`, `location`, and `maxEmails` to control targeting and size.
3. **Configure proxy settings** — if you want, set `proxyConfiguration` and choose an `engine` (`cost-effective` or `legacy`) for how the run should behave.
4. **Hit Run and watch the live log** — track progress and see when the actor finds and pushes new results.
5. **View results in the dataset tab** — each extracted lead record is written to the dataset as it’s found.
6. **Export as JSON, CSV, or Excel** — download the dataset directly from the Apify dashboard for use in your outreach or analysis workflow.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Reddit Email Scraper plugs directly into your existing workflow.

You can export results from the Apify dataset in standard formats like **JSON, CSV, and Excel** directly from the Apify dashboard. This makes it easy to use in spreadsheets, CRMs, and email list builder tools.

For automation and engineering workflows, you can connect your run using Apify’s **API access** and trigger downstream actions with **webhooks** (for example, pushing data to your next system when the run completes). You can also orchestrate data movement with **Zapier / Make** and set up **scheduled runs** to automate recurring collection.

For implementation details, refer to Apify docs: https://apify.com/docs/api

***

### Pricing & Free Trial

Reddit Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. In general, Apify uses a pay-as-you-go model billed for compute usage, so you can test small batches before scaling up. Subscription plans exist for heavier usage, and you’ll only pay for Apify platform compute rather than per-row fees. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Access interruptions | Retries and fallbacks to keep runs moving |
| Result scarcity | Logic to stop when repeated pages produce no new emails |
| Targeted email filtering | `customDomains` restrict what emails are accepted |
| Run stability | Progress is persisted so work is not lost mid-run |
| Scale of collection | Supports bulk runs while respecting `maxEmails` to control limits |

Limitations: The actor only works with **publicly available** emails found in the sources it can access. It can’t guarantee a minimum number of emails for every keyword/domain combination—if results seem low, re-run with broader keywords and more related terms or more domains.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes, Apify offers a **free tier** to help you run tests without committing immediately. Availability and exact credit amounts depend on your Apify account and current plan details.

#### Do I need to log in to Reddit to use this?

No. Reddit Email Scraper is designed to work with publicly available content and does not require a Reddit login in the normal setup.

#### How accurate is the data?

Accuracy depends on what email addresses are actually present in the publicly available Reddit bios and posts that match your `keywords`. The scraper extracts email addresses from those public texts and applies your `customDomains` filtering.

#### How many results can I get per run?

You control collection size using `maxEmails`, which is the maximum number of emails the scraper will collect before stopping. Note that setting a higher limit can allow more potential results but doesn’t guarantee reaching that number.

#### How often is the data updated / how fresh is it?

Freshness depends on when you run the actor. Each run scrapes publicly available data at runtime, so the dataset reflects the state of source content during that run.

#### Is this legal? Does it comply with GDPR / CCPA?

You should only use this tool in ways that comply with applicable laws and the platform’s rules. The actor works with **publicly available data**, but it’s still your responsibility to handle GDPR/CCPA and consent requirements appropriately for your use case.

#### Can I export results to Google Sheets or Excel?

Yes. You can export your dataset from the Apify dashboard in formats like **JSON, CSV, and Excel**, then import into tools like spreadsheets or CRMs. You can also connect workflows using Zapier/Make for automated export paths.

#### Can I run this on a schedule automatically?

Yes. Apify supports scheduled runs so you can run Reddit Email Scraper on a recurring schedule based on your collection needs.

#### Can I access this via API?

Yes. You can trigger and retrieve results programmatically using Apify’s API. See the Apify docs for details: https://apify.com/docs/api

#### What happens if the actor hits an error?

If access issues or empty results occur, the actor uses resilient logic with retries and stopping conditions. Progress is also persisted so you don’t lose already-collected results during a run.

***

### Need Help or Have a Request?

Got a question about Reddit Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We respond to requests and keep the actor maintained based on community feedback. If you want something like batch CSV upload for inputs or a webhook on completion, tell us what your workflow needs.

***

### Disclaimer & Responsible Use

*Reddit Email Scraper is the fastest, most reliable way to extract email addresses from publicly available Reddit bios and posts — start your free run today.*

The actor collects **publicly available data** and does not access private accounts, login-gated content, or password-protected pages. It’s your responsibility to comply with GDPR, CCPA, platform ToS, and any applicable local regulations when using the extracted data. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# 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("scraperoka/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("scraperoka/reddit-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": [
    "founder",
    "marketing"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ]
}' |
apify call scraperoka/reddit-email-scraper --silent --output-dataset

```

## MCP server setup

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