# Reddit Trends Scraper With Author Contact Leads (`simpleapi/reddit-trends-scraper`) Actor

Reddit Trends Scraper — Discover trending Reddit topics, posts, communities, and authors while extracting engagement metrics, post details, and publicly available author contact information. Build lead lists for audience research, trend analysis, outreach, and market intelligence.

- **URL**: https://apify.com/simpleapi/reddit-trends-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** Social media, Automation, Lead generation
- **Stats:** 3 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/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

### Reddit Trends Scraper — Author Contact Leads

Reddit Trends Scraper With Author Contact Leads turns a subreddit, user, keyword, or post URL into a lead list: every trending post paired with its author's real authority signals — karma, account age, verified/gold status, and a verified-email reachability flag — plus a best-effort mined email or external link from the author's public bio. It's built for growth and outreach teams sourcing leads from active Reddit communities, community managers assessing whether high-engagement posters are established or throwaway accounts, and researchers who need a reachability signal, not just a username. No Reddit login is required. Every section below documents an input, an output field, or exactly how the authority and contact-mining coverage works.

### What is Reddit Trends Scraper With Author Contact Leads?

This Actor scrapes Reddit's `old.reddit.com` listing pages for trending posts from a subreddit, user, keyword search, or direct URL, then enriches each post's author via their public `/user/<name>/about.json` profile — adding karma, account age, and a verified-email flag — and separately attempts to mine an email or external link from the author's public bio text.

Key capabilities, read from the source:

- **Two distinct signals, kept honestly separate.** `authorHasVerifiedEmail` (from the reliable `about.json` profile) is the trustworthy reachability signal; `authorContactEmail`/`authorContactLinks` (best-effort mined from bio text) is a separate, much lower-coverage field — the schema explicitly warns to expect "low single-digit percent email coverage" on the mined field and treats the verified-email flag as the real signal.
- **A fixed proxy trust-bug, documented in the source itself.** `resolve_proxy_url()`'s own comment states this fixes a bug where an earlier version ignored the user's proxy choice entirely — this Actor now genuinely honors an explicit `apifyProxyGroups`/`proxyUrls` setting, defaulting to `RESIDENTIAL` only when nothing more specific was requested, since Reddit hard-blocks datacenter IPs.
- **Per-author caching, with an explicit lookup cap.** `maxAuthorLookups` bounds total unique author profile fetches for a large run; authors beyond the cap still appear as post rows, just without enrichment — a repeat author within the cap costs one lookup regardless of how many posts they appear in.
- **Reachable-only output filter.** `contactsOnly` keeps only rows where the author is genuinely reachable — a mined email, a mined external link, or a verified-email account — dropping everything else before it's charged.
- **Flexible source resolution.** `build_reddit_url()` accepts a full URL, `u/username`, `r/subreddit`, or a bare keyword and resolves each to the correct `old.reddit.com` listing or search URL automatically.
- **`post_result`-charged rows, not `row_result`.** This Actor's charged event is named `post_result` — distinct from the `row_result` naming convention used by most other Actors in this catalogue.

### What data can I extract with Reddit Trends Scraper With Author Contact Leads?

Every field below is read directly from the row assembly in `main()` and `author_enrich.py`'s `build_author_fields()` — the dataset's default view surfaces all 26 as table columns.

#### Post fields

| Field | Example Value | Notes |
| --- | --- | --- |
| `title` / `postUrl` | post title / link | |
| `upvotes` / `comments` | `342` / `58` | |
| `subreddit` / `subredditUrl` / `subredditType` | community identity | |
| `author` / `authorProfile` | username / profile URL | |
| `postTime` | Reddit's own relative/absolute time | |

#### Author authority fields (from `about.json`)

| Field | Example Value | Notes |
| --- | --- | --- |
| `authorFound` / `authorSource` | `true` / `"about.json"` | Whether enrichment succeeded and via which path |
| `authorTotalKarma` / `authorLinkKarma` / `authorCommentKarma` | `45000` / `30000` / `15000` | |
| `authorCreatedAt` / `authorAccountAgeDays` | ISO date / `1825` | |
| `authorIsVerified` / `authorIsGold` / `authorIsMod` / `authorIsEmployee` | booleans | Reddit's own account badges |
| `authorHasVerifiedEmail` | `true` | The reliable reachability signal — near-100% coverage when enrichment succeeds |

#### Contact-mining fields (best-effort, low coverage)

| Field | Example Value | Notes |
| --- | --- | --- |
| `authorBio` | public bio text | |
| `authorContactEmail` | `jane@example.com` or `null` | Mined from bio text; expect low single-digit percent coverage, `null` when none found — never guessed |
| `authorContactLinks` | array of URLs | External links found in the bio |

### Why not build this yourself?

Reddit blocks datacenter IPs outright for its `old.reddit.com` surface, so a scraper without residential proxy support fails immediately regardless of how well the HTML parsing is built — this Actor's source explicitly documents fixing a prior version's bug where the user's own proxy choice was silently ignored, defaulting to residential only, which is exactly the kind of subtle correctness bug that's easy to ship and hard to notice until a run mysteriously fails. Separately, Reddit doesn't expose email addresses on-platform at all, so any "contact email" field is necessarily a best-effort bio-text mining exercise with inherently low coverage — this Actor is explicit about that limitation in its own schema copy rather than implying reliable email coverage, and provides the genuinely reliable `authorHasVerifiedEmail` flag as the real reachability signal instead.

### How to use data extracted from Reddit Trends Scraper With Author Contact Leads?

#### Growth and outreach lead generation

Search a niche subreddit or keyword, turn on `contactsOnly`, and get a filtered list of authors who are either verified-email accounts or have a mined contact point — a pre-qualified lead list rather than a raw post dump.

#### Community and influencer assessment

Use `authorTotalKarma` and `authorAccountAgeDays` alongside `authorIsVerified`/`authorIsGold` to distinguish established, credible posters from newer or throwaway accounts before deciding who's worth engaging.

#### Market and sentiment research with reachability

Scrape a topic's trending posts and use `authorHasVerifiedEmail` to identify which posters could plausibly be reached for a follow-up interview or survey.

#### AI agents and lead-scoring pipelines

Because `authorFound`/`authorSource` disclose exactly when enrichment succeeded or fell through, an agent can weight lead quality by enrichment confidence rather than trusting every row equally.

### 🔼 Input sample

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `startUrls` | **Yes** | array | Subreddit URLs, `r/subreddit`, `u/username`, full post/user URLs, or plain keywords. | `["https://old.reddit.com/r/startups/"]` |
| `sortBy` | No | string enum | `hot`, `new`, `top`, `rising`, `controversial`. Default `"hot"`. | `"top"` |
| `maxLeads` | No | integer | Posts to collect per source. Default `10`. | `50` |
| `enrichAuthors` | No | boolean | Fetch author authority signals via `about.json`. Default `true`. | `true` |
| `maxAuthorLookups` | No | integer | Cap on unique author lookups per run. `0` = unlimited. Default `0`. | `100` |
| `extractContacts` | No | boolean | Mine an email/links from the author's public bio. Best-effort, low coverage. Default `true`. | `true` |
| `emailDomainFilter` | No | array | Only keep a mined email ending in one of these domains. Empty = accept any. | `["gmail.com"]` |
| `contactsOnly` | No | boolean | Only emit rows with a genuinely reachable author. Default `false`. | `true` |
| `proxyConfiguration` | No | object | Defaults to `RESIDENTIAL`; an explicit group you set is honored. | `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}` |

```json
{
  "startUrls": ["https://old.reddit.com/r/startups/"],
  "sortBy": "top",
  "maxLeads": 50,
  "enrichAuthors": true,
  "contactsOnly": true
}
```

**Common pitfall:** this Actor's charged event is named `post_result`, not `row_result` — if you're monitoring costs across a catalogue of Actors that mostly use `row_result`, check for this Actor's distinct event name in your cost breakdown rather than assuming the naming is uniform.

### 🔽 Output sample

Output is one JSON row per post-author pair, pushed to the run's default dataset and charged as one `post_result` event per row.

```json
{
  "title": "How we grew to 10k users without paid ads",
  "postUrl": "https://reddit.com/r/startups/comments/1abcde/how_we_grew/",
  "upvotes": 342,
  "comments": 58,
  "subreddit": "startups",
  "author": "example_founder",
  "authorProfile": "https://reddit.com/user/example_founder",
  "authorFound": true,
  "authorSource": "about.json",
  "authorTotalKarma": 45000,
  "authorAccountAgeDays": 1825,
  "authorIsVerified": false,
  "authorHasVerifiedEmail": true,
  "authorBio": "Founder @ example.com",
  "authorContactEmail": null,
  "authorContactLinks": ["https://example.com/"],
  "scrapedAt": "2026-07-26T09:00:00Z"
}
```

### How do you filter and target specific leads?

**Reachability, not just activity, is the real qualifying filter.** `contactsOnly` is the highest-leverage input here — turning it on collapses the output to authors you can plausibly reach, rather than every post author regardless of whether any contact signal exists.

**Domain filtering narrows mined emails to your use case.** `emailDomainFilter` is useful when you specifically want personal-domain contacts (e.g. `gmail.com`) or are trying to exclude noreply/corporate addresses that happen to appear in bio text.

**Lookup caps control cost on very active sources.** `maxAuthorLookups` matters most on a large, high-volume subreddit — set it explicitly if you want to bound enrichment cost while still collecting the full post volume in `maxLeads`.

Three real examples:

```json
{ "startUrls": ["r/startups", "r/SaaS"], "sortBy": "top", "maxLeads": 50, "contactsOnly": true }
```

Pre-qualified reachable-leads-only sweep across two founder-heavy subreddits.

```json
{ "startUrls": ["indie hacker"], "sortBy": "new", "maxLeads": 100, "emailDomainFilter": ["gmail.com"] }
```

Broad keyword search filtered to personal-domain mined emails only.

```json
{ "startUrls": ["r/marketing"], "enrichAuthors": true, "extractContacts": false, "maxLeads": 200 }
```

Authority-signal-only run at higher volume, skipping the lower-value bio-mining step.

### ▶️ Want to try other scrapers?

| Scraper | What it extracts |
| --- | --- |
| Reddit Posts Scraper with Author Media Details | Full post metadata and media classification |
| Instagram Outreach Lead Scorer | Profiles scored for outreach fit |
| LinkedIn Profile Contact Extractor | Contact details parsed from a profile |
| Twitter/X Reply Scraper with Replier Contact Leads | Reply-thread leads with contact mining |

### How to extract Reddit lead data programmatically

This Actor runs as a standard Apify Actor call — one API call in, structured JSON dataset out, using your Apify API token.

#### Python example

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("<YOUR_USERNAME>/reddit-trends-scraper-with-author-contact-leads").call(run_input={
    "startUrls": ["https://old.reddit.com/r/startups/"],
    "sortBy": "top",
    "contactsOnly": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["author"], item["authorHasVerifiedEmail"], item.get("authorContactEmail"))
```

#### Export to spreadsheets or CRM

Every dataset supports one-click CSV/Excel export from the Apify Console. Map `author`, `authorContactEmail`, and `authorContactLinks` directly into a CRM's lead fields.

### Is it legal to scrape Reddit for leads?

Scraping publicly visible Reddit posts and public profile bios is generally lawful, since this data is published for anyone to view without logging in — the underlying legal question was tested directly in *hiQ Labs v. LinkedIn* (9th Cir.), which held that scraping public, non-password-protected data does not violate the U.S. Computer Fraud and Abuse Act. Mined contact emails and Reddit usernames can constitute personal data under GDPR/CCPA when tied to an identifiable individual, so treat outreach and storage accordingly, and be aware that unsolicited email outreach is separately regulated in most jurisdictions (CAN-SPAM, GDPR). Consult legal counsel before using this data for outbound campaigns.

### ❓ FAQ

#### What's the difference between authorHasVerifiedEmail and authorContactEmail?

`authorHasVerifiedEmail` is a reliable boolean from Reddit's own `about.json` profile — near-100% coverage when enrichment succeeds, and it's the trustworthy reachability signal. `authorContactEmail` is a completely separate, best-effort attempt to mine an actual email address from the author's public bio text — coverage is genuinely low (single-digit percent) since Reddit doesn't expose emails on-platform at all.

#### Why would an author lack enrichment even with enrichAuthors on?

Either the author is a non-user placeholder (like `[deleted]`), or `maxAuthorLookups` was reached before this author's turn — `authorFound: false` or a `null` `authorSource` on the row tells you which case applies.

#### Does contactsOnly filter out unenriched authors too?

Yes — a row only survives `contactsOnly` if it has a mined email, a mined link, or `authorHasVerifiedEmail: true`. An author with no enrichment at all (enrichment off, or lookup cap reached) won't have any of those signals and gets dropped.

#### Do I need a Reddit account to use this?

No — post scraping uses `old.reddit.com`'s public listing pages, and author enrichment uses the public `/user/<name>/about.json` endpoint; neither requires a login.

#### Why does Reddit require a residential proxy specifically?

Reddit hard-blocks datacenter IPs on `old.reddit.com` — a documented, tested behavior this Actor's source addresses directly, defaulting to the `RESIDENTIAL` Apify proxy group unless you explicitly request a different one.

#### How does this compare to other lead-generation scrapers?

As observed on the Apify Store on 2026-07-26, `automation-lab/website-contact-finder` and `scraplib/google-maps-lead-generation` both mine contact data, but from websites and Google Maps listings respectively rather than Reddit post authors with karma-based authority signals — that combination is specific to this Actor.

#### Does this work with AI agent frameworks?

Yes — call it as a standard HTTP endpoint via the Apify API from any agent framework capable of making an API call; there's no MCP-specific integration for this Actor.

### Conclusion

Reddit Trends Scraper With Author Contact Leads turns trending Reddit posts into a lead list — real authority signals from Reddit's own profile data, honestly separated from low-coverage, best-effort bio-mined contact info. It fits outreach, community assessment, and research workflows that need a reachability signal attached to every author. Start a run from the Apify Console or the Apify API with your target subreddits or keywords to get your first lead export.

# Actor input Schema

## `startUrls` (type: `array`):

Add subreddit URLs (e.g. https://old.reddit.com/r/startups/), r/subreddit shorthand, u/username, a full post/user URL, or a plain keyword to search. Each source is expanded into posts, and every post author is enriched. Supports bulk input.

## `sortBy` (type: `string`):

How the source listing is sorted before authors are collected. Example: sortBy=top surfaces the highest-authority posters. Default is hot.

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

Maximum number of posts (each becomes one enriched author-lead row) to collect per source. Example: maxLeads=25. Default is 10.

## `enrichAuthors` (type: `boolean`):

Look up each post author via their public /user/<name>/about.json profile to add total/link/comment karma, account creation date, account age in days, verified, gold, mod/employee, and the has-verified-email reachability flag. Turn OFF to return only the base post fields. Default is ON.

## `maxAuthorLookups` (type: `integer`):

Cap the number of unique author profile lookups per run to control runtime on large sources. 0 = unlimited. Authors beyond the cap still appear as rows but without enrichment. Default is 0.

## `extractContacts` (type: `boolean`):

Best-effort scrape of an email address and external links from the author's PUBLIC profile bio. Coverage is thin — Reddit does not expose emails on-platform, so most authors yield no email (the field is left null, never faked). The has-verified-email flag above is the reliable reachability signal. Default is ON.

## `emailDomainFilter` (type: `array`):

Only keep a mined email when it ends with one of these domains (e.g. gmail.com, hey.com, yourcompany.com). Leave empty to accept any domain. Applies to the mined authorContactEmail only.

## `contactsOnly` (type: `boolean`):

Emit only rows whose author is reachable — a mined email, a mined external link, OR a verified-email account. Everything else is dropped. Default is OFF (every post is emitted).

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

Proxy used for all requests. Reddit blocks datacenter IPs, so this actor defaults to Apify RESIDENTIAL proxy; an explicit proxy group you set here is honored.

## Actor input object example

```json
{
  "startUrls": [
    "https://old.reddit.com/r/startups/"
  ],
  "sortBy": "hot",
  "maxLeads": 10,
  "enrichAuthors": true,
  "maxAuthorLookups": 0,
  "extractContacts": true,
  "emailDomainFilter": [],
  "contactsOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped items in the Actor's default dataset.

# 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 = {
    "startUrls": [
        "https://old.reddit.com/r/startups/"
    ],
    "emailDomainFilter": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/reddit-trends-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 = {
    "startUrls": ["https://old.reddit.com/r/startups/"],
    "emailDomainFilter": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/reddit-trends-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 '{
  "startUrls": [
    "https://old.reddit.com/r/startups/"
  ],
  "emailDomainFilter": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call simpleapi/reddit-trends-scraper --silent --output-dataset

```

## MCP server setup

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