# Reddit Answers Scraper (`nice_dev/reddit-answers-scraper`) Actor

Ask Reddit Answers (the AI of reddit.com/answers) many questions in one run: summary, Markdown answer, sections, quotes with links, follow-up questions, and the cited posts, comments and communities with their full text. For RAG, n8n and AI agents.

- **URL**: https://apify.com/nice\_dev/reddit-answers-scraper.md
- **Developed by:** [Nice Dev](https://apify.com/nice_dev) (community)
- **Categories:** Social media, AI, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.70 / 1,000 answers

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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?

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

### 💬 What is Reddit Answers Scraper?

**Reddit Answers Scraper** asks **[Reddit Answers](https://www.reddit.com/answers/)** — the AI of Reddit that answers a question from real Reddit discussions — **as many questions as you like in one run**, and returns each answer as structured data: **summary, full answer in Markdown, sections, every quote with the comment it comes from, follow-up questions, and the cited posts, comments and communities with their full text, author and score**. It works as a **Reddit Answers API alternative**: run it on a schedule, call it from your code, or plug it into Make, Zapier or n8n.

Type your questions (or paste shared Reddit Answers links), click **Start**, and download the answers in JSON, CSV or Excel, or feed them straight to your AI pipeline, n8n workflow or agent. No login, nothing to set up: an answer takes 3 to 9 seconds, and 5 questions are asked at once.

### 📋 What data can you extract from Reddit Answers?

One item per answer, 26 fields:

| Category | What you get |
| --- | --- |
| 💬 **The answer** | the question, a short summary, the whole answer as Markdown and as plain text, its language |
| 🗂️ **Structure** | sections with their title, text, bullet points and the sources each one cites |
| 🗨️ **Quotes** | every Reddit quote of the answer, with the link of the comment it comes from |
| 🔎 **Research steps** | what the AI of Reddit searched for before answering |
| ➕ **Follow-ups** | the 3 follow-up questions Reddit suggests — and, if you want, their answers too |
| 📰 **Cited posts** | title, full text, author, score, upvote ratio, number of comments, flair, date — and their top comments |
| 👤 **Cited comments** | full text, author, score, date, and the post they belong to |
| 👥 **Communities** | name, title, description, number of members, icon |
| 🖼️ **Images** | the images Reddit shows with the answer, with their source |

Every field, with an example, is listed in the **Output** section below. The full text, authors and scores of the sources come with **Full text of the sources** (on by default); without it you still get the answer, the quotes and the links.

### ✅ Why use Reddit Answers Scraper?

- 📚 **Many questions in one run**: give 1 or 1,000 questions, they are asked 5 at a time — not one run per question.
- 🧠 **Ready for AI**: the answer in Markdown with its quotes as links, the same in plain text for embeddings, sections for chunking.
- 🔗 **Sources you can check**: every quote carries the comment it comes from; the cited posts and comments come with their full text, author and score.
- ➕ **Follow-up questions answered too**: turn on **Answer the follow-up questions** to dig one level deeper automatically.
- 🔔 **Monitoring built in**: with **Only new questions**, a scheduled run answers only the questions added since the last one.
- 🆓 **A question Reddit declines costs nothing**: it is saved with `status: "refused"` so that you know, and it is not charged.
- 🔌 API, scheduling, integrations (n8n, Make, Zapier, Google Sheets…) and JSON/CSV/Excel export via the Apify platform.

### 🚀 How to scrape Reddit Answers

1. Create a free Apify account.
2. Open **Reddit Answers Scraper** and type a **Question** (e.g. `What espresso machine do Redditors recommend for beginners?`).
3. Add more in **More questions** (one per line), or paste shared Reddit Answers links into **Reddit Answers URLs**.
4. Choose what comes with each answer: **Full text of the sources** (on by default), **Top comments per cited post**, **Answer the follow-up questions**. Then click **Start**.
5. Download the dataset in JSON, CSV, Excel or via API.

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

This Actor uses **pay per event** pricing: you pay **per answer** Reddit gives (a question Reddit declines is free), plus a small fee per run start. The options are charged apart, only when you turn them on: **full text of the sources** per answer, and **top comments** per cited post. Platform usage (compute, proxy) is included in the price.

| What you pay for | Price per 1,000 (no subscription → Gold plan and above) |
| --- | --- |
| An answer Reddit gives | $9.00 → $8.70 |
| Full text of the sources (on by default), per answer | $9.00 → $8.70 |
| Top comments of a cited post, per post | $2.75 → $2.72 |
| Run start | $0.001 per run |

The exact price for your plan is shown in the **Pricing** tab.

### ⚙️ Input

One question:

```json
{
    "question": "What espresso machine do Redditors recommend for beginners?"
}
```

Several questions, with the top comments of each cited post and one follow-up answer per question:

```json
{
    "questions": ["best note taking app for students", "Welche Kaffeemühle empfehlen Anfänger?"],
    "sourcePostComments": 5,
    "followUpAnswers": 1
}
```

Monitoring a growing list, only the questions never answered before:

```json
{
    "questions": ["best CRM for small agencies", "best budget standing desk"],
    "onlyNew": true,
    "stateKey": "product-research"
}
```

| Field | Notes |
| --- | --- |
| `question`, `questions` | Your questions, as you would type them on reddit.com/answers (max 500 characters each, up to 1,000 per run). The same question given twice is asked once. |
| `startUrls` | Shared Reddit Answers links, e.g. `https://www.reddit.com/answers/99d3d84d-6b02-4ff7-be6a-44cd2cb7ea89/?q=best+arkham+game`: the question of each link is asked again. |
| `maxItems` | Stop after this many answers for the whole run, follow-ups included (`0` = no limit: one answer per question and per follow-up). |
| `followUpAnswers` | Also answer up to this many of the 3 follow-up questions Reddit suggests with each answer (`0` = none, max 3). |
| `enrichSources` | Full text, author, score and date of the cited posts and comments, details of the communities (default on). |
| `sourcePostComments` | Top comments to read for each cited post (`0` = none, max 25). |
| `includeRawDocument` | Add Reddit's own answer document (`document`) for your own rendering. |
| `onlyNew`, `stateKey`, `resetState` | Monitoring: only the questions never answered under this memory key; `resetState` forgets the memory. |
| Advanced | `proxyConfiguration` (Apify proxy by default, included in the price; the residential proxy is not available), `maxConcurrency`, `maxRequestsPerMinute`, `minRequestIntervalMs`, `maxRequestRetries`, `debugLog`. |

### 📦 Output

One answer, shortened (one element of each list, long texts cut):

```json
{
    "id": "0f9f174c-789c-4e46-ab6a-7f42851a6448",
    "url": "https://www.reddit.com/answers/0f9f174c-789c-4e46-ab6a-7f42851a6448/?q=What+do+people+recommend+for+learning+Rust+in+2026%3F&source=ANSWERS",
    "query": "What do people recommend for learning Rust in 2026?",
    "status": "answered",
    "rejectionCodes": [],
    "isFollowUp": false,
    "parentQuery": null,
    "parentId": null,
    "language": "en",
    "summary": "To learn Rust in 2026, focus on practical application and foundational computer science concepts, leveraging official resources and hands-on projects, rather than relying solely on AI or extensive reading.",
    "markdown": "To learn Rust in 2026, **focus on practical application and foundational computer science concepts**, leveraging official resources and hands-on projects...\n\n### Master the Fundamentals\n\n- **Prioritize core programming concepts**: ...",
    "text": "To learn Rust in 2026, focus on practical application and foundational computer science concepts, ...",
    "sections": [
        {
            "title": "Master the Fundamentals",
            "text": "Prioritize core programming concepts: Understand data structures, design patterns...",
            "items": ["Prioritize core programming concepts: Understand data structures, design patterns..."],
            "citations": [
                {
                    "sourceId": "t1_p6dvhx0",
                    "sourceType": "comment",
                    "url": "https://www.reddit.com/r/rust/comments/1w0lk1q/comment/p6dvhx0/",
                    "displayText": "\"Knowing how to think like an engineer is more important than the language you learn.\"",
                    "subreddit": "rust"
                }
            ]
        }
    ],
    "quotes": [
        {
            "text": "\"Knowing how to think like an engineer is more important than the language you learn.\"",
            "sourceUrl": "https://www.reddit.com/r/rust/comments/1w0lk1q/comment/p6dvhx0/",
            "sourceId": "t1_p6dvhx0",
            "sourceType": "comment",
            "subreddit": "rust"
        }
    ],
    "followUpQueries": ["Best online courses for Rust", "Top Rust programming books", "Rust community forums and resources"],
    "researchSteps": ["Searching for learning Rust 2026 recommendations", "Consolidating what redditors are saying"],
    "sourcePosts": [
        {
            "id": "t3_1u5o9hd",
            "url": "https://www.reddit.com/r/rust/comments/1u5o9hd/how_did_you_learn_rust_looking_for_advice_for_a/",
            "subreddit": "rust",
            "title": "How did you learn Rust? (Looking for advice for a newcomer)",
            "author": "Glad_Supermarket3951",
            "body": "I wanted to dive into Rust, and the learning curve is definitely something that's hitting hard...",
            "score": 40,
            "upvoteRatio": 0.84,
            "numComments": 44,
            "flair": "🙋 seeking help & advice",
            "isNsfw": false,
            "linkUrl": null,
            "createdAt": "2026-06-14T15:34:12.000Z",
            "isTopPost": false,
            "comments": [
                {
                    "id": "t1_orm7zwk",
                    "url": "https://www.reddit.com/r/rust/comments/1u5o9hd/how_did_you_learn_rust_looking_for_advice_for_a/orm7zwk/",
                    "author": "Psy_Fer_",
                    "body": "I started going through \"the book\" which is just the docs on the rust website...",
                    "score": 25,
                    "createdAt": "2026-06-14T15:42:00.000Z"
                }
            ]
        }
    ],
    "sourceComments": [
        {
            "id": "t1_p6dvhx0",
            "url": "https://www.reddit.com/r/rust/comments/1w0lk1q/which_programming_languagefield_should_i_focus_on/p6dvhx0/",
            "subreddit": "rust",
            "quote": "\"Knowing how to think like an engineer is more important than the language you learn.\"",
            "author": "FemaleMishap",
            "body": "Don't learn a programming language. Spend your time learning the theory. Study data structures, design patterns...",
            "score": 7,
            "createdAt": "2026-08-28T09:38:04.000Z",
            "parentId": "t3_1w0lk1q",
            "postId": "t3_1w0lk1q",
            "postTitle": "Which programming language/field should I focus on in 2026?",
            "postUrl": "https://www.reddit.com/r/rust/comments/1w0lk1q/which_programming_languagefield_should_i_focus_on/",
            "postAuthor": "No-Creme2356"
        }
    ],
    "recommendedSubreddits": [
        {
            "id": "t5_2r7yd",
            "name": "learnprogramming",
            "url": "https://www.reddit.com/r/learnprogramming/",
            "title": "learn programming",
            "description": "A subreddit for all questions related to programming in any programming language",
            "subscribers": 4415167,
            "iconUrl": null,
            "isNsfw": false,
            "createdAt": "2009-09-24T04:25:37.000Z"
        }
    ],
    "relatedMedia": [],
    "postCount": 11,
    "commentCount": 12,
    "subredditCount": 4,
    "sourcesEnriched": true,
    "document": null,
    "scrapedAt": "2026-09-25T22:50:13.369Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV or Excel.

#### All 26 fields

| Fields | What you get |
| --- | --- |
| `id`, `url` | the id of the answer, its shareable reddit.com link |
| `query`, `isFollowUp`, `parentQuery`, `parentId` | the question; for a follow-up answer, the question and the answer it follows |
| `status`, `rejectionCodes` | `answered`, or `refused` when Reddit declines the question (with its reason codes) or its answer cites no post or comment: not charged |
| `language`, `summary` | `en`, `de`, `es-419`… (null when Reddit serves an answer it gave before), the short answer (first paragraph) |
| `markdown`, `text` | the whole answer in Markdown (quotes as links) and in plain text |
| `sections` | title, text, bullet points and citations of each part of the answer |
| `quotes` | text, link of the comment, id, type and community of each quote (translated by Reddit when the answer is in another language than the comment) |
| `followUpQueries`, `researchSteps` | the follow-up questions Reddit suggests; what its AI searched for (only its last step on an answer served from Reddit's memory) |
| `sourcePosts` | id, link, community, title, text, author, score, upvote ratio, comments, flair, NSFW, linked URL, date, in the Top posts block, top `comments` |
| `sourceComments` | id, link, community, quote, full text, author, score, date, parent, post id, title, link and author |
| `recommendedSubreddits` | id, name, link, title, description, members, icon, NSFW, date |
| `relatedMedia` | image link, width, height, and the comment or post it comes from |
| `postCount`, `commentCount`, `subredditCount` | how many posts, comments and communities the answer cites |
| `sourcesEnriched`, `document`, `scrapedAt` | sources read or not; Reddit's raw document (`includeRawDocument`); when the answer was given |

### 💡 Tips

#### How to get better answers

Ask the way you would ask a friend on Reddit: "What do Redditors recommend for…", "What are common mistakes when…", "Is X worth it?". Reddit answers in the language of the question (English, French, German, Spanish, Portuguese and Italian are answered). A question already asked recently is answered at once from Reddit's own memory.

#### How to reduce costs

The price is per answer, so the levers are the number of questions, `maxItems` and `followUpAnswers`. The source details and the top comments are charged apart: turn them off when the answer and its quotes are enough. With **Only new questions** a scheduled run never pays twice for the same question.

#### Monitoring: only the new questions

Tick **Only new questions** (`onlyNew`) and schedule the Actor with a list of questions you add to over time. The first run answers everything; each later run skips the questions already answered, and those Reddit declined: they are not asked again and not charged. Questions are compared without case, accents or extra spaces. The memory lives in a named key-value store of your account (`reddit-answers-scraper-seen`, up to 100,000 questions per key) and only holds questions whose row really reached the dataset. Give each schedule its own `stateKey`, and tick `resetState` once to start over (to get fresh answers to the same questions).

### 🔌 Integrations and API

Call the Actor via the Apify API, the JavaScript or Python clients, or connect it with integrations and webhooks (n8n, Make, Zapier, Google Sheets, Slack, Airtable…). The dataset can be fetched as JSON or CSV from any tool: one item per answer, the `markdown` field ready to paste into a prompt.

### 🤖 Use with AI agents (MCP)

AI agents (Claude, ChatGPT, Cursor…) can find and run this Actor through the [Apify MCP server](https://mcp.apify.com), billed to their Apify account like any run. It returns one item per answer of Reddit Answers. Actor id: `nice_dev/reddit-answers-scraper`; MCP server with this Actor only: `https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/reddit-answers-scraper`.

Smallest input, for a cheap first call:

```json
{
    "question": "best budget mechanical keyboard for programming",
    "enrichSources": false
}
```

Key output fields: `query`, `summary`, `markdown`, `quotes`, `followUpQueries`, `sourcePosts` and `sourceComments` (with `enrichSources`).

Cost: per answer Reddit gives plus a small run-start fee, see the pricing section above. Cap each call with `maxItems` and, through the API, with the run option `maxTotalChargeUsd`.

### ❓ FAQ

#### Is it legal to scrape Reddit Answers?

The Actor only asks Reddit Answers what any anonymous visitor of reddit.com can ask, and reads the public posts and comments it cites. It logs in to nothing. Results contain the usernames and texts of Reddit users, which can be personal data protected by GDPR: do not store them without a legitimate reason. You are responsible for using the data in compliance with Reddit's Terms of Use and Public Content Policy and with applicable law. This Actor is not affiliated with Reddit.

#### Does it need a login or a proxy?

No login and no Reddit account. The proxy is included in the price: leave the default setting (the residential proxy is not available). A question Reddit turns away is retried at once on a new proxy session, up to 10 times on top of the retries (without a proxy, after a pause of 5 seconds, doubled at each retry up to 255 seconds).

#### Why was a question "refused"?

Reddit Answers declines some prompts: questions it considers unsafe, some languages (Japanese, for example), and questions over its length limit (the form refuses more than 500 characters before asking). Such a question is saved with `status: "refused"`, its `rejectionCodes` and Reddit's own sentence in `summary` / `markdown`, and it is not charged. A question for which Reddit finds nothing to cite is marked the same way.

#### Is the data safe to open in Excel or to show on a web page?

Answers, posts and comments are the words of Reddit and of its users, copied as they are. A text can begin with `-`, `+`, `=` or `@`: Excel and Google Sheets may read such a cell of a CSV file as a formula. The Actor leaves the text as it is, so that the JSON and the API give the real value: when you open a CSV, import these columns as text. Every URL field holds an http(s) URL or null. On a web page, escape every text field like any text written by a stranger. The `markdown` field is safe to render as Markdown: Reddit's words are escaped in it (`<div>` is written `&lt;div>`, `[text](url)` is written `\[text\](url)`), so it holds no HTML and no link but the ones of the answer itself (quotes, posts, communities on reddit.com, and its http(s) images). The `body` of posts and comments is Markdown as its author typed it: render it with a Markdown renderer that removes HTML.

#### Known limitations

- Reddit Answers gives one answer per question; the same question asked again is often answered from Reddit's memory, with the same text.
- `onlyNew` remembers questions, not answers: an answer that changed on Reddit is not returned again unless you reset the memory.
- Follow-up questions are answered one level deep (the follow-ups of a follow-up are not asked).
- Two runs sharing the same `stateKey` at the same time may both answer the same new question.

**A run the platform stops without warning** (out of memory, run timeout)

- Resurrect it: it goes on from where it stood at most a minute before the stop. The answers already saved are skipped: none is delivered or charged twice, and `maxItems` still counts them.
- With `onlyNew`, the memory is saved once a minute: resurrect the stopped run and the questions it had answered meanwhile join the memory.

#### Something doesn't work?

The last line of the log counts the answers saved, the questions Reddit declined, those skipped by `onlyNew`, the answers saved without their sources, and the questions that failed after every retry. Those failures are listed, with the reason, in the `FAILED_REQUESTS` record of the run's key-value store. A run that saved nothing and had failed questions fails, and its last message gives the cause.

If Reddit changes its answers, you are told instead of paying for blank rows: if the first 5 answers all lack their summary, their answer, their cited posts or — with the sources — the titles of those posts, the run saves nothing more, stops and fails, and its last message names the missing field.

### 🛟 Support

Open an issue in the **Issues** tab with a link to your run: the run log and the `FAILED_REQUESTS` record of the key-value store show exactly which questions failed and why.

# Actor input Schema

## `question` (type: `string`):

A question for Reddit Answers, as you would type it on reddit.com/answers (e.g. `best budget espresso machine for beginners`). English, French, German, Spanish, Portuguese and Italian are answered. Max 500 characters.

## `questions` (type: `array`):

Several questions in one run, one per line (e.g. `best CRM for small agencies`, `Welche Kaffeemühle empfehlen Anfänger?`): one answer per question, asked in parallel. Added to **Question**; the same question given twice is asked once. Max 1 000 questions of 500 characters.

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

Shared Reddit Answers links (e.g. `https://www.reddit.com/answers/99d3d84d-6b02-4ff7-be6a-44cd2cb7ea89/?q=best+arkham+game`): the question in the link is asked again and answered. Added to the questions above. Max 1 000 URLs.

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

Maximum number of answers to save for the whole run, follow-up answers included. 0 = one answer per question (and per follow-up), no other limit.

## `followUpAnswers` (type: `integer`):

Reddit suggests 3 follow-up questions with each answer. Ask up to this many of them too, each saved as its own answer (and charged as one). 0 = only your questions.

## `enrichSources` (type: `boolean`):

Add the full post and comment text, author, score and date of every cited source, the parent post of each cited comment, and the details of each suggested community (members, description). Off = the answer with its quotes and links only (faster).

## `sourcePostComments` (type: `integer`):

Also read the top comments of each cited post (up to this many per post; about 10 cited posts per answer, one extra request each). 0 = none.

## `includeRawDocument` (type: `boolean`):

Add Reddit's own answer document (`document`: every block, list, quote, image and source as Reddit renders them) for your own rendering. It adds about 10 KB to each result.

## `onlyNew` (type: `boolean`):

Skip the questions that a previous run (same **Memory key**) already answered or that Reddit declined: they are not asked again and not charged. Questions are compared without case, accents or extra spaces. First run = every question is new.

## `stateKey` (type: `string`):

Name of the memory used by **Only new questions**. Give each schedule / task its own key (e.g. `product-research`) so that they do not share their memory. Letters, digits, `-` and `_`.

## `resetState` (type: `boolean`):

Forget everything remembered under this **Memory key** before the run: this run answers (and charges) every question again. Untick it afterwards.

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

Apify Proxy or your own proxies. Keep the default: it is included in the price. The residential Apify proxy is not available in this Actor.

## `maxConcurrency` (type: `integer`):

Maximum number of questions asked in parallel (an answer takes 3 to 9 seconds).

## `maxRequestsPerMinute` (type: `integer`):

Most requests to Reddit in any 60 seconds, all of them counted: questions, sources and comment threads. A budget, not an even pace (spread them with the minimum delay below). Lower it if Reddit answers HTTP 429 / 403 in the log.

## `minRequestIntervalMs` (type: `integer`):

Smallest gap between two requests, in milliseconds. Unlike the per-minute rate, this spreads the requests evenly instead of letting them go out in a burst. 0 = no gap.

## `maxRequestRetries` (type: `integer`):

Retries per question before it is marked as failed. Behind a proxy, a question Reddit turns away is also retried on a new proxy session up to 10 times without using up these retries.

## `debugLog` (type: `boolean`):

Include debug messages in the run log.

## Actor input object example

```json
{
  "question": "What espresso machine do Redditors recommend for beginners?",
  "questions": [],
  "startUrls": [],
  "maxItems": 0,
  "followUpAnswers": 0,
  "enrichSources": true,
  "sourcePostComments": 0,
  "includeRawDocument": false,
  "onlyNew": false,
  "stateKey": "default",
  "resetState": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 5,
  "maxRequestsPerMinute": 120,
  "minRequestIntervalMs": 0,
  "maxRequestRetries": 5,
  "debugLog": false
}
```

# 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 = {
    "question": "What espresso machine do Redditors recommend for beginners?",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nice_dev/reddit-answers-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 = {
    "question": "What espresso machine do Redditors recommend for beginners?",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nice_dev/reddit-answers-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 '{
  "question": "What espresso machine do Redditors recommend for beginners?",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nice_dev/reddit-answers-scraper --silent --output-dataset

```

## MCP server setup

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