# Reddit Scraper with Jev AI - Sentiment, Intent & Leads (`abdullahbilal-y/reddit-jev-ai-scraper`) Actor

Scrape Reddit posts and comments by subreddit, keyword, user or post URL. Every result is analysed by the Jev AI model for sentiment, intent, buying intent and pain points at no extra cost, and AI filters run before billing so you only pay for what you keep.

- **URL**: https://apify.com/abdullahbilal-y/reddit-jev-ai-scraper.md
- **Developed by:** [Abdullah Bilal](https://apify.com/abdullahbilal-y) (community)
- **Categories:** Social media, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Reddit Scraper with Jev AI - Sentiment, Intent & Leads

### What does Reddit Scraper with Jev AI do?

This Actor scrapes **[Reddit](https://www.reddit.com) posts and comments** — from subreddits, keyword searches, user profiles, or post URLs — and runs **AI analysis on every result at no extra charge**.

Each post and comment comes back with **sentiment, intent, emotion, buying-intent probability, pain-point probability, recommendation-request probability and spam probability**, plus an optional **relevance score** for your own topic and answers to **up to 10 yes/no questions you write yourself**.

The part that saves you money: **AI filters run before billing.** Ask for "only posts with 70%+ buying intent" and everything below that is dropped before it reaches your dataset — and since Apify bills per dataset item, **you don't pay for rows you filtered out.**

Analysis is powered by **[Jev](https://typesafe.ai), TypeSafe AI's System One model**, which returns calibrated probabilities rather than generated text — fast, consistent, and cheap enough that it is simply included. Already have your own Jev access? Paste your **Vercel AI Gateway** or **TypeSafe** key and the analysis runs on it.

Running on Apify gives you an API, scheduling, webhooks, and exports to JSON, CSV, Excel and Google Sheets.

### Why use it?

- **Lead generation** — find people actively asking for a tool like yours: filter by buying intent or the `seeking_recommendation` intent.
- **Pain-point research** — collect real complaints about a problem space before you build.
- **Brand and competitor monitoring** — track sentiment about your product, or ask "Mentions \[competitor]?" as a custom question.
- **Market research** — see what a community actually cares about, with the noise filtered out.
- **Content ideas** — surface the questions people keep asking.

### What you get

| | |
|---|---|
| AI analysis | **included in the per-result price** — no add-on fee |
| AI on the Apify free plan | **yes** |
| Custom yes/no questions | **up to 10, included** |
| Filtered rows | **not billed as results** |
| Comments | only fetched for posts that pass your filters, so you don't pay for threads you screened out |
| Per-run start fee | **$0.00005** |
| Bring your own key | optional — Vercel AI Gateway or TypeSafe |

### How to use it

1. Click **Try for free**.
2. Pick a **mode**: Subreddits, Keyword search, Users, or Post URLs.
3. Fill the matching field.
4. Optional: add **your topic** for relevance scoring, **your own questions**, and **AI filters**.
5. Press **Start**, then download from the **Output** tab — the **Leads** view sorts by buying intent.

### Input

| Field | Description |
|---|---|
| `mode` | `subreddit`, `search`, `user` or `post` |
| `subreddits` / `searchQueries` / `usernames` / `postUrls` | What to scrape, depending on mode |
| `sort`, `timeFilter` | Hot / new / top / rising, or search relevance; time range for top and search |
| `maxItems` | Posts read per subreddit, query or user (up to 1,000) |
| `includeComments`, `maxCommentsPerPost`, `commentSort` | Also collect comment threads of the posts you keep |
| `enableAiAnalysis` | AI fields on every result (on by default, no extra cost) |
| `topic` | Adds a 0–1 `aiRelevance` score |
| `customQuestions` | Up to 10 yes/no questions, each answered as a 0–1 probability |
| `vercelAiGatewayKey`, `typesafeApiKey` | Optional: run the AI on your own key. Stored encrypted |
| `minBuyingIntentPct`, `minPainPointPct`, `minRelevancePct`, `excludeSpam`, `onlySentiments`, `onlyIntents`, `requireAllCustomTrue` | AI filters — applied before billing |
| `minScore`, `minComments`, `excludeNsfw` | Standard filters — also applied before billing |

Lead-generation example:

```json
{
  "mode": "search",
  "searchQueries": ["notion alternative", "best project management tool"],
  "sort": "new",
  "timeFilter": "week",
  "maxItems": 100,
  "topic": "project management software for small teams",
  "customQuestions": ["Mentions Asana, Trello or Monday.com?"],
  "onlyIntents": ["seeking_recommendation", "complaint", "purchase_intent"],
  "excludeSpam": true
}
```

### Output

Posts and comments are separate results. Download as JSON, HTML, CSV or Excel.

```json
{
  "type": "post",
  "id": "t3_1wl2t46",
  "title": "anything similar to notion that's not obsidian?",
  "text": "my biggest issue with obsidian is it does not nicely group pages together...",
  "subreddit": "Notion",
  "author": "lunar-waves",
  "score": 75,
  "numComments": 60,
  "createdAt": "2026-09-20T00:55:16+00:00",
  "url": "https://www.reddit.com/r/Notion/comments/1wl2t46/...",
  "aiStatus": "ok",
  "aiSentiment": "negative",
  "aiIntent": "seeking_recommendation",
  "aiEmotion": "frustration",
  "aiBuyingIntent": 0.82,
  "aiPainPoint": 0.91,
  "aiWantsRecommendation": 0.97,
  "aiSpam": 0.02,
  "aiRelevance": 0.88,
  "aiCustom": { "Mentions Asana, Trello or Monday.com?": 0.11 }
}
```

#### Data fields

| Field | Description |
|---|---|
| `type` | `post` or `comment` |
| `title`, `text` | Post title and body, or comment text |
| `subreddit`, `author`, `score`, `numComments`, `upvoteRatio`, `flair`, `postType`, `domain`, `linkUrl` | Reddit metadata |
| `postId`, `parentId`, `depth` | Comment threading |
| `createdAt`, `url` | Timestamp and permalink |
| `aiSentiment`, `aiIntent`, `aiEmotion` | Labels, with confidence for sentiment and intent |
| `aiBuyingIntent`, `aiPainPoint`, `aiWantsRecommendation`, `aiSpam` | 0–1 probabilities |
| `aiRelevance` | 0–1, when you set a topic |
| `aiCustom` | Your questions and their 0–1 answers |
| `aiStatus` | `ok`, or `unavailable` if analysis could not run — the result is still returned |

### How much does it cost to scrape Reddit?

Billing is **per result** (one post or one comment), with AI analysis included in that price. There is no separate AI fee and the per-run start fee is a fraction of a cent. The Apify free tier covers trying it. See the **Pricing** tab for the current numbers.

**Filtered results are not billed as results** — including results removed by AI filters. If you set a maximum cost for a run, the Actor stops scraping when it is reached instead of working on for nothing.

### Tips

- **Find people paying for work, not people advertising it.** r/forhire tags posts as \[Hiring] or \[For Hire]. Search `flair:hiring subreddit:forhire chatbot` (swap in your service) with sort **New** to get only buyers, then add a yes/no question like "Is this about building an AI chatbot?" and tick "all my questions are yes".
- **Sort keyword searches by Relevance.** "New" matches loose words and pulls in off-topic posts; narrow it with `subreddit:`, `flair:` or `title:` if you need the newest.
- **For leads, filter by intent, not keywords.** `onlyIntents: ["seeking_recommendation"]` finds people asking for help even when they don't use your keyword.
- **Write specific custom questions.** "Is the author a small business owner?" works better than "Is this relevant?".
- **Use `sort: new` with a daily schedule** to monitor a topic as it happens.
- **Comments multiply results.** Turn on `includeComments` only when you need the threads.

### FAQ

**Do I need a Reddit account or API key?**
No. Only publicly visible content is collected, with no login.

**Do I need my own AI or TypeSafe key?**
No. AI analysis is included and runs on our side. If you already pay for Jev through Vercel AI Gateway or TypeSafe, you can paste your key instead.

**Why do search results have shorter text than subreddit results?**
Reddit's search pages carry each post's title, not the full body, so the AI judges search results from the title. For full post text - and sharper AI scores - scrape the subreddit instead, or run the post URLs from your search through Post URL mode for the discussion.

**Why did User mode return newest posts when I asked for top?**
For some accounts Reddit renders an empty page for the top- or hot-sorted list. Rather than return nothing, the Actor falls back to the account's newest posts and says so in the run log.

**How many comments can I get per post?**
Reddit shows 25 comments per view. Above 25, the Actor combines several sort orders to collect more — typically 20–90 per busy thread, capped at your `maxCommentsPerPost` (up to 100). Very large threads will not be returned in full.

**Why did I get fewer posts than `maxItems`?**
Reddit ends its listings at roughly 1,000 posts, and its search serves 7 posts per page and usually stops after 100–250 per query — add more queries to cover more ground. Small communities simply have fewer posts. The run log says how many pages Reddit served and why it stopped.

**Why doesn't Post URL mode return the post itself?**
Reddit does not expose a single post's details through the pages this Actor reads, so Post URL mode returns the comment thread. To get post details, use Subreddit, Search or User mode — with `includeComments` if you want both.

**How far back can I go?**
Reddit caps listings at roughly the most recent 1,000 posts per sort order. Use `top` with a time range for older high-signal posts.

**How accurate is the AI?**
Every label comes with a probability, and results are generally good on clear posts and weaker on sarcasm, very short comments and niche jargon. Treat scores as a strong filter and ranking signal, not ground truth.

### Legal and disclaimer

This Actor collects only **publicly available Reddit content**, with no login and no access to private communities or messages. You are responsible for how you use the data, including compliance with Reddit's terms, GDPR, CCPA and other applicable law. Posts and comments can contain personal data — only process it where you have a valid legal basis.

### Support

Found a bug or want a feature? Open a ticket on the **Issues** tab. Requests genuinely shape what gets built next.

# Actor input Schema

## `mode` (type: `string`):

Pick one. Each mode uses its own input field below.

## `subreddits` (type: `array`):

Names, r/names or subreddit URLs.

## `searchQueries` (type: `array`):

Keywords or phrases. Reddit search syntax works, e.g. 'notion alternative subreddit:productivity'.

## `usernames` (type: `array`):

Usernames, u/names or profile URLs.

## `postUrls` (type: `array`):

Full Reddit post links. Returns the comment thread of each post.

## `sort` (type: `string`):

Subreddits: hot, new, top, rising (Relevance falls back to Hot). Search: Relevance is best - "New" matches loose words and returns off-topic posts unless you narrow the query with subreddit:, flair: or title:. Users: new, hot, top.

## `timeFilter` (type: `string`):

Used by Top sort and by search.

## `maxItems` (type: `integer`):

How many posts to read per subreddit, query or user. Pages are fetched automatically. Reddit itself stops around 1,000 posts per listing, and search usually stops after 100-250 per query.

## `includeComments` (type: `boolean`):

Fetch the comment thread of every post that passes your filters. Each comment is returned (and billed) as its own result.

## `maxCommentsPerPost` (type: `integer`):

Includes visible nested replies. Reddit shows 25 comments per view; above 25, the Actor merges several sort orders to collect more (up to 100). Very large threads will not be returned in full.

## `commentSort` (type: `string`):

Which comments come first.

## `enableAiAnalysis` (type: `boolean`):

Adds sentiment, intent, emotion, buying intent, pain point, recommendation request and spam probability to every post and comment, powered by the Jev model from TypeSafe AI. No extra charge from this Actor. Runs after the free filters, so only rows that survive them are analysed.

## `topic` (type: `string`):

Optional. Describe what you care about - e.g. 'project management software for small teams' - and every result gets a 0-1 relevance score.

## `customQuestions` (type: `array`):

Up to 10. Each is answered for every result as a 0-1 probability, e.g. 'Mentions Asana or Trello?' or 'Is the author a small business owner?'. Included in the price.

## `vercelAiGatewayKey` (type: `string`):

Use your own key for the AI analysis. Vercel AI Gateway serves the Jev model at TypeSafe's own price. Stored encrypted; never logged. Leave empty to use the built-in key.

## `typesafeApiKey` (type: `string`):

Alternative to the Vercel key: a key from typesafe.ai. Stored encrypted; never logged.

## `minBuyingIntentPct` (type: `integer`):

Drop results below this buying-intent probability. Filtered rows never reach your dataset, so they are not billed as results - only the small filtered-result fee shown on the Pricing tab, if any.

## `minPainPointPct` (type: `integer`):

Drop results unlikely to describe a real problem. Filtered rows never reach your dataset, so they are not billed as results - only the small filtered-result fee shown on the Pricing tab, if any.

## `minRelevancePct` (type: `integer`):

Requires a topic. Drop off-topic results. Filtered rows never reach your dataset, so they are not billed as results - only the small filtered-result fee shown on the Pricing tab, if any.

## `excludeSpam` (type: `boolean`):

Drop results the AI judges to be spam, ads or the author plugging their own product. Filtered rows never reach your dataset, so they are not billed as results - only the small filtered-result fee shown on the Pricing tab, if any.

## `onlySentiments` (type: `array`):

Leave empty to keep all.

## `onlyIntents` (type: `array`):

Leave empty to keep all. E.g. pick 'seeking\_recommendation' and 'complaint' for lead generation.

## `requireAllCustomTrue` (type: `boolean`):

Treats a probability of 50% or more as yes.

## `minScore` (type: `integer`):

Drop results below this score. Filtered rows never reach your dataset, so they are not billed as results - only the small filtered-result fee shown on the Pricing tab, if any.

## `minComments` (type: `integer`):

Drop posts with fewer comments.

## `excludeNsfw` (type: `boolean`):

Drops results Reddit marks as NSFW. Best effort: it relies on Reddit's own marking.

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

Required, and already set. Reddit blocks Apify's server IPs and datacenter proxies; residential proxies work reliably.

## Actor input object example

```json
{
  "mode": "subreddit",
  "subreddits": [
    "SaaS",
    "startups"
  ],
  "searchQueries": [
    "notion alternative"
  ],
  "sort": "relevance",
  "timeFilter": "week",
  "maxItems": 10,
  "includeComments": false,
  "maxCommentsPerPost": 25,
  "commentSort": "best",
  "enableAiAnalysis": true,
  "minBuyingIntentPct": 0,
  "minPainPointPct": 0,
  "minRelevancePct": 0,
  "excludeSpam": false,
  "requireAllCustomTrue": false,
  "excludeNsfw": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "subreddits": [
        "SaaS",
        "startups"
    ],
    "searchQueries": [
        "notion alternative"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abdullahbilal-y/reddit-jev-ai-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 = {
    "subreddits": [
        "SaaS",
        "startups",
    ],
    "searchQueries": ["notion alternative"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abdullahbilal-y/reddit-jev-ai-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 '{
  "subreddits": [
    "SaaS",
    "startups"
  ],
  "searchQueries": [
    "notion alternative"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call abdullahbilal-y/reddit-jev-ai-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abdullahbilal-y/reddit-jev-ai-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/I7XJOJZDAhBSYfCmz/builds/AqeBmrb6oFIrmOhea/openapi.json