# Reddit User Profile (`truefetch/reddit-user-profile`) Actor

Reddit user profile scraper returning 33 structured profile fields plus optional post and comment history for one public account. Covers karma, account age, trophies, moderated communities, stored media, polls, and external links. From $0.03375 per profile.

- **URL**: https://apify.com/truefetch/reddit-user-profile.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Social media, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 358 total users, 11 monthly users, 100.0% runs succeeded, 5 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.03375 / result

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

## Reddit User Profile

### What does Reddit User Profile do?

Reddit User Profile turns a username or profile URL into an exportable account record with karma, biography, public profile details and selected post and comment history. Use it to research known authors, enrich an account list and inspect public activity with links back to Reddit.

Choose how much authored history you need. Set either history cap to zero when the workflow only needs profile details or the other activity type.

### How do I run Reddit User Profile?

1. Open the Input tab and use the small example below.
2. Click **Start** and wait for that run to finish.
3. Open the default **Dataset** to inspect the row, then export JSON or CSV. Read the final status with the profile: a saved profile can coexist with incomplete requested history.

```json
{
  "username": "nasa",
  "max_posts": 2,
  "max_comments": 2
}
```

Set `max_posts` and `max_comments` independently; zero skips that history type.

### What data does Reddit User Profile return?

One Dataset row represents one Reddit user profile; the public contract has 39 top-level fields.

| Group | Fields |
| --- | --- |
| Identity | `status`, `id`, `name`, `username`, `url`, `about`, `created_at`, `created_date` |
| Profile presentation | `avatar`, `avatar_size`, `banner`, `banner_size`, `profile_color`, `snoovatar` |
| Verification and karma | `verified`, `verified_email`, `post_karma`, `comment_karma`, `awardee_karma`, `awarder_karma`, `total_karma` |
| Additional public facts | `is_admin`, `contribution_count`, `active_community_count`, `social_links` |
| Audience and state | `follower_count`, `accept_followers`, `is_premium`, `is_employee`, `is_moderator`, `is_suspended`, `over_18`, `robots_hidden` |
| Collections | `trophies`, `moderated`, `posts`, `comments` |
| Provenance | `processor`, `processed_at` |

This abbreviated example truncates every nested collection; real rows may contain many more fields inside posts, comments, trophies, and communities:

```json
{
  "status": "success",
  "id": "illustrative-account-id",
  "username": "nasa",
  "url": "https://www.reddit.com/user/nasa/",
  "post_karma": 1200,
  "comment_karma": 300,
  "total_karma": 1500,
  "is_employee": null,
  "trophies": [{"name": "15-Year Club"}],
  "moderated": [{"name": "r/announcements", "subscribers": 302603085}],
  "posts": [{"id": "1u7hraf", "title": "21 years of Reddit", "score": 840}],
  "comments": [{"id": "os0o1vi", "score": 95, "is_root": false}],
  "processor": "https://apify.com/truefetch/reddit-user-profile",
  "processed_at": "2026-11-06T13:00:00Z"
}
```

Types below describe populated values; optional facts remain `null` when unavailable. Preserve genuine zero and `false` values. For a found profile, a zero history cap returns `[]`; requested history is `[]` when confirmed empty and `null` when unavailable. A `not_found` row keeps both histories `null`. Stored-file fields contain successful saved references; unsaved list members are removed.

The example is illustrative. `created_date` is a calendar date; `created_at` is an exact source instant when supplied.

#### Result kinds

`status: success` means the profile was found. A run can retain that row and still finish with a warning about requested history, optional detail, media, saving, or billing. There is no `partial` row status. `status: not_found` requires an explicit missing-account response; its unknown facts are null and it has no Profile lookup (`result`), Post, or Comment event. An unavailable lookup yields no invented row and an availability message. Invalid input is rejected. A run stopped by a spending limit retains already saved rows.

#### Profile fields

| Field | Type | Meaning |
| --- | --- | --- |
| `id` | string | Reddit's internal account identifier; suspended accounts may omit it. |
| `name` | string | Display name shown on the profile when the account set one. |
| `username` | string | Canonical Reddit username without the u/ prefix. |
| `url` | string | Public Reddit profile URL. |
| `avatar` | string | Saved avatar URL when file saving succeeds. |
| `avatar_size` | array | Source-reported avatar width and height in pixels. |
| `banner` | string | Saved banner URL when file saving succeeds. |
| `banner_size` | array | Source-reported profile banner width and height in pixels. |
| `profile_color` | string | Profile theme color reported by Reddit. |
| `about` | string | Profile biography text. |
| `verified` | boolean | Reddit's account verification flag. |
| `verified_email` | boolean | Whether Reddit reports that the account verified an email address. |
| `post_karma` | integer | Karma earned from submissions. |
| `comment_karma` | integer | Karma earned from comments. |
| `awardee_karma` | integer | Karma earned from awards received. |
| `awarder_karma` | integer | Karma earned from awards given. |
| `total_karma` | integer | Total account karma; this may remain available for a suspended account. |
| `follower_count` | integer | Public subscriber count for the user's profile community. |
| `created_at` | string | ISO 8601 account creation time from Reddit. |
| `snoovatar` | boolean | Whether the account prefers to show its Snoovatar. |
| `accept_followers` | boolean | Whether the account accepts followers. |
| `is_premium` | boolean | Whether the account has Reddit Premium. |
| `is_employee` | boolean | Whether the account belongs to Reddit staff. |
| `is_moderator` | boolean | Whether Reddit identifies the account as a moderator. |
| `is_suspended` | boolean | True when Reddit reports that the account is suspended. |
| `over_18` | boolean | Whether the profile is marked for adult content. |
| `robots_hidden` | boolean | Whether the profile asks search engines not to index it. |
| `trophies` | array | Available trophy names, descriptions and links; icon saving is optional. |
| `moderated` | array | Available community identity, URL and audience count. |
| `posts` | array | Authored post objects, bounded by `max_posts`; see the history meanings above. |
| `comments` | array | Authored comment objects, bounded by `max_comments`; see the history meanings above. |
| `processor` | string | Apify Actor URL that processed this record. |
| `processed_at` | string | ISO 8601 timestamp when this record was processed. |
| `status` | string | success for a public profile; not_found only when Reddit explicitly confirms absence. |
| `created_date` | string | Source-published account creation date when an exact instant is unavailable. |
| `is_admin` | boolean | Explicit public Reddit Admin role; employment is not inferred. |
| `contribution_count` | integer | Source-published profile contribution count. |
| `active_community_count` | integer | Source-published count of active communities. |
| `social_links` | array | Public profile links with source labels and platform types. |

#### Post fields

| Field | Type | Meaning |
| --- | --- | --- |
| `id` | string | Native Reddit identifier without a fullname type prefix, when available. |
| `post_url` | string | Public Reddit page identifying this entity. |
| `title` | string | Source-reported title. |
| `body` | string | Source-disclosed text from the accepted page. |
| `subreddit` | string | Source-reported subreddit name. |
| `subreddit_id` | string | Source-reported subreddit record id. |
| `subreddit_type` | string | Source-reported subreddit type. |
| `subreddit_subscribers` | integer | Native subscriber count of the post community. |
| `created_at` | string | Native publication time converted from epoch seconds to UTC. |
| `edited_at` | string | Native edit time converted from epoch seconds; false and unavailable sentinels are null. |
| `flair_text` | string | Source-reported flair text. |
| `author_flair_text` | string | Source-reported author flair text. |
| `score` | integer | Native score; may be negative and is not a total vote count. |
| `upvote_ratio` | number | Native fraction of post votes that are upvotes. |
| `comment_count` | integer | Native post comment total, not the size of a retrieved list. |
| `crosspost_count` | integer | Source-reported crosspost count. |
| `award_count` | integer | Source-reported award count. |
| `gild_count` | integer | Source-reported gild count. |
| `crosspost_parent_id` | string | Source-reported crosspost parent record id. |
| `crosspost_parent_url` | string | Source-reported crosspost parent url. |
| `crosspost_parent_title` | string | Source-reported crosspost parent title. |
| `crosspost_parent_author` | string | Source-reported crosspost parent author name. |
| `crosspost_parent_subreddit` | string | Source-reported crosspost parent subreddit name. |
| `media_type` | string | Source-reported media type. |
| `media_url` | string | Stored media URL when available; otherwise the external destination linked by the post, then its crosspost parent URL, or null. `crosspost_parent_url` remains present. A self-post permalink is not an external destination. |
| `media_provider_name` | string | Source-reported media provider name. |
| `media_title` | string | Source-reported media title. |
| `media_author_name` | string | Source-reported media author name. |
| `media_width` | integer | Native media width in pixels. |
| `media_height` | integer | Native media height in pixels. |
| `media_duration_seconds` | number | Native Reddit video duration in seconds. |
| `media_bitrate_kbps` | number | Native Reddit video bitrate in kilobits per second. |
| `media_has_audio` | boolean | Native Reddit video audio flag. |
| `media_is_gif` | boolean | Native Reddit video animated-GIF flag. |
| `domain` | string | Native linked domain; self.<community> sentinels are null. |
| `thumbnail` | string | Saved thumbnail URL. |
| `images` | array | Distinct stored-file URLs for successfully saved images, in native order. Null when Reddit did not show image facts; unsaved members are removed, so a known image list can become \[]. |
| `gallery_captions` | array | Complete nonblank captions in native gallery order. |
| `categories` | array | Native content categories. |
| `poll` | object | Source-reported poll. |
| `discussion_type` | string | Source-reported discussion type. |
| `suggested_sort` | string | Source-reported suggested sort. |
| `replies_enabled` | boolean | Native reply-notification preference, not an observed reply count. |
| `score_hidden` | boolean | Source-reported is score hidden. |
| `allow_live_comments` | boolean | Native flag permitting live comments. |
| `is_crosspostable` | boolean | Source-reported is crosspostable. |
| `contest_mode` | boolean | Source-reported is contest mode. |
| `is_meta` | boolean | Source-reported is meta. |
| `media_only` | boolean | Source-reported is media only. |
| `quarantined` | boolean | Source-reported is quarantined. |
| `is_self` | boolean | Source-reported is self. |
| `is_video` | boolean | Source-reported is video. |
| `is_original` | boolean | Source-reported is original content. |
| `is_gallery` | boolean | Source-reported is gallery. |
| `distinguished` | string | Source-reported distinguished. |
| `removed_by` | string | Source-reported removed by category. |
| `indexable` | boolean | Source-reported is indexable. |
| `over_18` | boolean | Native adult-content flag. |
| `spoiler` | boolean | Source-reported is spoiler. |
| `locked` | boolean | Source-reported is locked. |
| `stickied` | boolean | Source-reported is stickied. |
| `pinned` | boolean | Source-reported is pinned. |
| `archived` | boolean | Source-reported is archived. |
| `duplicates` | array | Reserved duplicate-post URLs; normally null. |

#### Comment fields

| Field | Type | Meaning |
| --- | --- | --- |
| `id` | string | Native Reddit identifier without a fullname type prefix, when available. |
| `comment_url` | string | Public Reddit page identifying this entity. |
| `body` | string | Source-disclosed text from the accepted page. |
| `subreddit` | string | Source-reported subreddit name. |
| `subreddit_id` | string | Source-reported subreddit record id. |
| `subreddit_type` | string | Source-reported subreddit type. |
| `created_at` | string | Native publication time converted from epoch seconds to UTC. |
| `edited_at` | string | Native edit time converted from epoch seconds; false and unavailable sentinels are null. |
| `flair_text` | string | Source-reported flair text. |
| `score` | integer | Native score; may be negative and is not a total vote count. |
| `score_hidden` | boolean | Source-reported is score hidden. |
| `controversiality` | integer | Source-reported controversiality. |
| `award_count` | integer | Source-reported award count. |
| `gild_count` | integer | Source-reported gild count. |
| `over_18` | boolean | Native adult-content flag. |
| `replies_enabled` | boolean | Native reply-notification preference, not an observed reply count. |
| `is_collapsed` | boolean | Source-reported is collapsed. |
| `quarantined` | boolean | Source-reported is quarantined. |
| `is_root` | boolean | True when the native parent fullname identifies a submission rather than another comment. |
| `parent_id` | string | Source-reported parent record id. |
| `post_id` | string | Source-reported post record id. |
| `post_title` | string | Source-reported post title. |
| `post_url` | string | Source-reported post url. |
| `external_url` | string | Source-reported external destination of the parent post, excluding its Reddit permalink. |
| `post_author` | string | Source-reported post author name. |
| `post_comment_count` | integer | Native total for the comment parent post, not retrieved children. |
| `is_submitter` | boolean | Source-reported is submitter. |
| `distinguished` | string | Source-reported distinguished. |
| `stickied` | boolean | Source-reported is stickied. |
| `locked` | boolean | Source-reported is locked. |
| `archived` | boolean | Source-reported is archived. |
| `images` | array | Stored inline image URLs in source order. |

#### Trophy fields

| Field | Type | Meaning |
| --- | --- | --- |
| `id` | string | Native Reddit identifier without a fullname type prefix, when available. |
| `name` | string | Source-reported title. |
| `icon` | string | Stored-file URL when the icon was saved. |
| `description` | string | Source-disclosed text from the accepted page. |
| `granted_at` | string | Native trophy grant time converted from epoch seconds to UTC. |
| `url` | string | Public Reddit page identifying this entity. |

#### Moderated community fields

| Field | Type | Meaning |
| --- | --- | --- |
| `id` | string | Native Reddit identifier without a fullname type prefix, when available. |
| `name` | string | Source-reported subreddit name. |
| `title` | string | Source-reported title. |
| `url` | string | Public Reddit page identifying this entity. |
| `subscribers` | integer | Native community subscriber count. |
| `created_at` | string | Native creation time converted from epoch seconds to UTC. |
| `over_18` | boolean | Native adult-content flag. |
| `subreddit_type` | string | Source-reported subreddit type. |
| `icon` | string | Stored-file URL when the icon was saved. |
| `icon_size` | array | Source-reported image width and height in pixels. |
| `banner` | string | Stored-file URL when the community banner was saved. |
| `banner_size` | array | Source-reported banner width and height in pixels. |
| `primary_color` | string | Source-reported primary color. |
| `key_color` | string | Source-reported key color. |

#### Post poll fields

| Field | Type | Meaning |
| --- | --- | --- |
| `end_at` | string | Native poll end time converted from epoch milliseconds to UTC. |
| `total_votes` | integer | Source-reported total vote count. |
| `is_prediction` | boolean | Source-reported is prediction. |
| `resolved_id` | string | Source-reported resolved option id. |
| `options` | array | Native poll options; an empty list is retained only when supplied. |

#### Poll option fields

| Field | Type | Meaning |
| --- | --- | --- |
| `id` | string | Native Reddit identifier without a fullname type prefix, when available. |
| `text` | string | Source-reported title. |

#### Social link fields

| Field | Type | Meaning |
| --- | --- | --- |
| `title` | string | Source label for the profile link. |
| `url` | string | Absolute destination supplied by the profile. |
| `type` | string | Source link category, normalized to lowercase. |

Stored media links are available only when the media could be saved. Post media_url can instead contain the external destination linked by the post. Missing stored scalar links are null; missing members are removed from media URL arrays. External article and thread links keep their source meaning. Intrinsic dimensions, exact dates, role flags, followers, preferences, poll facts, and duplicate links can remain unknown; a declared field does not promise a populated value. Post and comment arrays describe authored activity rather than a reconstructed reply tree.

### What inputs can I configure?

| Input | Type | Default / sample | Effect |
| --- | --- | --- | --- |
| `username` | string | Required; sample `"nasa"` | Reddit account to look up. Accepts a plain username, a u/ prefix, or a full profile URL — 'spez', 'u/spez' and 'https://www.reddit.com/user/spez/' all resolve to the same account. |
| `max_posts` | integer | Required; sample `2` | Maximum authored posts per profile, newest first. Zero skips posts. There is no input ceiling; only available public history is returned, and an unavailable continuation is reported. |
| `max_comments` | integer | Required; sample `2` | Maximum authored comments per profile, newest first then top for additional distinct comments. Zero skips comments. There is no input ceiling; unavailable history is reported. |

### What platforms and markets does Reddit User Profile cover?

This Actor looks up one known Reddit user. It accepts a plain username, `u/name` or a Reddit profile URL. It does not search posts by keyword, collect a subreddit feed or bypass hidden history. Post and comment caps are requested maxima; only public history actually served by Reddit can be included.

### Why use Reddit User Profile?

Keep profile facts and selected activity in the same record rather than manually joining separate exports. Source links make the history useful for author review, and independent caps let a workflow request only the activity it needs.

An explicit missing-account answer differs from a temporary lookup failure. Read the final run message alongside the Dataset, especially when history is hidden or a requested detail could not be retrieved.

### Who is Reddit User Profile for?

- **Author research:** look up a known account with a small post and comment cap to review public interests and activity.
- **Account enrichment:** use zero history caps when you need biography, creation date and karma without authored history.
- **Community context:** inspect available moderated communities and follow their links for a separate community lookup.
- **Repeatable monitoring:** save the input as an Apify Task, add a Schedule and compare the exported account snapshots by username and `processed_at`.

### How can I use Reddit User Profile through the API or MCP?

The account-qualified Actor name is `truefetch~reddit-user-profile`. Each example starts once, polls that run and retrieves every default-Dataset page. Set `APIFY_TOKEN` in your own environment; never put a token into a shared URL, committed file or public log. The examples use the same complete profile input as Quick Start.

A client wait ending can leave the Actor running. Poll the existing run ID; starting again can create another run and another bill. If the initial start response is lost, check your run list before submitting again. A terminal FAILED, TIMED-OUT or ABORTED run can still have saved data, so the examples read its Dataset too.

#### cURL and jq

Requires cURL, jq and a POSIX shell. Save the run ID printed by the script. Requests use the Authorization header rather than a token query parameter.

```bash
set -eu
: "${APIFY_TOKEN:?Set APIFY_TOKEN}"
BASE=https://api.apify.com/v2
INPUT='{"username":"nasa","max_posts":2,"max_comments":2}'
RUN=$(curl --fail-with-body --silent --show-error   -H "Authorization: Bearer $APIFY_TOKEN" -H 'Content-Type: application/json'   --data "$INPUT" "$BASE/acts/truefetch~reddit-user-profile/runs")
RID=$(printf '%s' "$RUN" | jq -er '.data.id')
printf 'Run ID: %s
' "$RID" >&2
while :; do
  RUN=$(curl --fail-with-body --silent --show-error     -H "Authorization: Bearer $APIFY_TOKEN" "$BASE/actor-runs/$RID")
  STATUS=$(printf '%s' "$RUN" | jq -r '.data.status')
  case "$STATUS" in SUCCEEDED|FAILED|TIMED-OUT|ABORTED) break;; esac
  sleep 3
done
DID=$(printf '%s' "$RUN" | jq -r '.data.defaultDatasetId // empty')
printf 'Final status: %s
' "$STATUS" >&2
if [ -n "$DID" ]; then
  OFFSET=0
  while :; do
    PAGE=$(curl --fail-with-body --silent --show-error       -H "Authorization: Bearer $APIFY_TOKEN"       "$BASE/datasets/$DID/items?format=json&clean=false&limit=1000&offset=$OFFSET")
    printf '%s' "$PAGE" | jq -c '.[]'
    COUNT=$(printf '%s' "$PAGE" | jq 'length')
    [ "$COUNT" -lt 1000 ] && break
    OFFSET=$((OFFSET + COUNT))
  done
fi
```

#### Python

Uses Python 3 and the `requests` package. The start request is not automatically repeated. A later client error does not cancel the Actor; retain the printed run ID and resume polling it.

```python
import json
import os
import time
import requests

BASE = "https://api.apify.com/v2"
session = requests.Session()
session.headers["Authorization"] = "Bearer " + os.environ["APIFY_TOKEN"]
run_input = {'username': 'nasa', 'max_posts': 2, 'max_comments': 2}

def get(path, **params):
    response = session.get(BASE + path, params=params, timeout=60)
    response.raise_for_status()
    return response.json()

response = session.post(BASE + "/acts/truefetch~reddit-user-profile/runs", json=run_input, timeout=60)
response.raise_for_status()
run = response.json()["data"]
run_id = run["id"]
print("Run ID:", run_id, flush=True)
terminal = {"SUCCEEDED", "FAILED", "TIMED-OUT", "ABORTED"}
while run["status"] not in terminal:
    time.sleep(3)
    run = get("/actor-runs/" + run_id)["data"]
print("Final status:", run["status"])
dataset_id = run.get("defaultDatasetId")
if dataset_id:
    offset = 0
    while True:
        page = get("/datasets/" + dataset_id + "/items", format="json",
                   clean="false", offset=offset, limit=1000)
        for item in page:
            print(json.dumps(item, ensure_ascii=False))
        if len(page) < 1000:
            break
        offset += len(page)
```

#### JavaScript

Uses Node.js 18 or later with built-in `fetch`. Save as an ES module (`.mjs`) and set `APIFY_TOKEN`. It does not need an additional SDK package. A failed HTTP request ends this client, not necessarily the remote run.

```javascript
const base = 'https://api.apify.com/v2';
const token = process.env.APIFY_TOKEN;
if (!token) throw new Error('Set APIFY_TOKEN');
const input = {"username": "nasa", "max_posts": 2, "max_comments": 2};
async function api(path, options = {}) {
  const response = await fetch(base + path, {
    ...options,
    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
  });
  if (!response.ok) throw new Error(`Apify HTTP ${response.status}`);
  return response.json();
}
let { data: run } = await api('/acts/truefetch~reddit-user-profile/runs', {
  method: 'POST', body: JSON.stringify(input),
});
const runId = run.id;
console.log('Run ID:', runId);
const terminal = new Set(['SUCCEEDED', 'FAILED', 'TIMED-OUT', 'ABORTED']);
while (!terminal.has(run.status)) {
  await new Promise(resolve => setTimeout(resolve, 3000));
  ({ data: run } = await api(`/actor-runs/${runId}`));
}
console.log('Final status:', run.status);
if (run.defaultDatasetId) {
  for (let offset = 0; ; ) {
    const page = await api(`/datasets/${run.defaultDatasetId}/items?format=json&clean=false&limit=1000&offset=${offset}`);
    for (const item of page) console.log(JSON.stringify(item));
    if (page.length < 1000) break;
    offset += page.length;
  }
}
```

#### Make, n8n and downstream tools

In Make, select Apify's **Run an Actor**, use the Actor ID above, map the same JSON input and retain the returned run ID. Wait for that run to finish, then use **Get Dataset Items** with its `defaultDatasetId`; configure pagination rather than assuming the first page is the whole result. In n8n, use the Apify Actor action and pass the same input; retain the run and Dataset IDs between nodes. If the workflow stops waiting, resume polling the existing run.

For a media archive, fetch the saved avatar, banner and image references returned in the profile and nested collections. A post's `media_url` may be an external destination rather than a saved file. For analytics, ingest Dataset JSON with its source links and `processed_at` timestamp.

For an MCP workflow, connect an Apify-supported MCP client and select this Actor with the same input keys. The [API page](https://apify.com/truefetch/reddit-user-profile/api) provides the integration entry points. Keep the run ID so a client disconnect does not lead to a second run.

### How much does Reddit User Profile cost?

Pay per event. FREE is an Apify plan name, not a zero-price promise. The Pricing tab shows the applicable plan.

| Event | When it applies | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Actor Start (`apify-actor-start`) | Once per run | $0.01 | $0.01 | $0.01 | $0.01 | $0.01 | $0.01 |
| Result (`result`) | One found profile | $0.045 | $0.0405 | $0.036 | $0.03375 | $0.03375 | $0.03375 |
| Post (`post`) | Each included post | $0.0065 | $0.00585 | $0.0052 | $0.00488 | $0.00488 | $0.00488 |
| Comment (`comment`) | Each included comment | $0.00125 | $0.00113 | $0.001 | $0.00094 | $0.00094 | $0.00094 |

#### Whole-bill example

Illustrative FREE-plan bill for one found profile, two included posts and two included comments: $0.01 startup + $0.045 profile + $0.0130 posts + $0.00250 comments = **$0.07050**. This uses the Quick Start caps when both are filled; fewer included items reduce the history component.

Only included history items count toward Post and Comment events. A confirmed missing user has no Profile lookup, Post or Comment fee. The startup charge still applies to empty or unsuccessful work. If billing confirmation is pending, inspect that same run before starting another.

### How does Reddit User Profile compare with alternatives?

Use Reddit directly for a manual profile review. Use authorized Reddit developer access when your application needs permissions or account actions beyond public profile lookup. This Actor is useful for exporting a known account with selected authored history; use Reddit Search API for discovering posts by topic.

### What are the limits and troubleshooting steps?

- **User-hidden history ->** requested hidden posts remain unavailable (`null`). Requested comments may also remain `null`; hidden history is not guaranteed. Confirmed empty history is `[]`. Read the final run message for unavailable sections.
- **Fewer items than requested →** the caps are maximums and Reddit controls how much public activity is available → retry with `1` to distinguish source availability from volume.
- **User not found →** the account may be misspelled or deleted → verify the public profile URL, then retry the exact username.
- **Missing or restricted profile →** an explicit absence yields `status: not_found`; a refusal yields an unavailable notice. Restricted-profile field coverage varies; unknown flags are not `false`.
- **Spending limit →** collection stops when delivery or billing is refused. Already saved data remains. Inspect the Dataset and charged events; do not automatically rerun an uncertain charge.
- **Nested arrays look flattened →** tabular exports cannot preserve every nested object cleanly → use JSON or JSONL.
- **Optional-details warning →** `Completed | 1 profile · Some optional details could not be collected` means the requested posts and comments were delivered, but optional information such as duplicate links, moderation details or media was unavailable. Read the final run message for unavailable requested history.
- **Temporary retrieval failure →** public source availability varies → retry later with the smallest input before increasing the workload.

For a reproducible defect, open an [Actor issue](https://apify.com/truefetch/reddit-user-profile/issues) with the public run ID, exact input, and expected outcome. Never include an API token or unrelated personal data.

Use public content only, follow the source platform's terms and applicable law, and ensure you have permission to download, store or reuse media and personal data. This Actor does not grant reuse rights. Keep private inputs and credentials out of public support messages.

### Frequently asked questions

#### Can I run a bulk reddit user lookup?

Yes, by launching one run per username through the API, Tasks, or an orchestrator. Each run intentionally accepts one identity and produces one profile row.

#### Does it support reddit karma and history export?

Yes. Export the profile karma fields and requested posts and comments from the Dataset. The output reference lists all fields; shared missing-value meanings apply.

#### What does a profile-only lookup cost?

At the FREE tier, a found profile with both activity caps at `0` has a $0.05500 Actor-event subtotal. Adding two included posts and two included comments gives the Quick Start subtotal of $0.07050. See Pricing for all tiers.

#### Can I schedule runs to monitor Reddit profiles over time?

Yes. Create an Apify Schedule with a fixed username and compare snapshots by `processed_at`; interpret changes as observations, not explanations.

#### Can I pass a full profile URL?

Yes. A username, `u/` handle, and full profile URL normalize to the same account identifier.

#### Are posts and comments complete histories?

No. The arrays are bounded by the requested caps and by the public activity available during the run.

#### Do I need Reddit credentials?

No credential field exists in the three-input schema. You need an Apify account or token to start the Actor.

#### Is karma an exact count of upvotes?

No. Reddit describes karma as an approximate reflection of votes. Treat it as a source-reported signal rather than audited engagement.

#### Why did the run finish with a warning after saving a profile?

The saved profile and the missing part are separate facts. A warning can identify unavailable requested history, optional details, media, or an unconfirmed charge. Keep the saved row and read the final status before retrying.

After an interrupted run, compare saved posts and comments with the requested caps and final warnings before retrying; a saved profile alone does not establish complete history.

#### What does Billing confirmation is pending mean?

The row may already be saved while billing confirmation is pending. Inspect that same run's charged events and Dataset; starting another run can repeat work and charges. If billing is still pending, retain the run ID and contact support before starting another run.

#### Why are there no rows after a temporary failure?

The public profile could not be retrieved during that run. This differs from an explicit missing-user result. Verify the username, retain the run ID, and try the smallest workload later if needed.

### Related TrueFetch Actors

- [Image Search Download API](https://apify.com/truefetch/image-search-download-api) - Use a topic from `about` or a returned post `title` as `keyword` to find related images.
- [Academic Search API](https://apify.com/truefetch/academic-search-api) - Use a research topic from `about`, post `title` or comment `body` as `keyword` to find papers.
- [Job Search](https://apify.com/truefetch/job-search) - When `about` or a returned post names a role, skill or company, use that term as `keyword`; choose a country and result limit to search vacancies.

### Support

Use the [Issues page](https://apify.com/truefetch/reddit-user-profile/issues) for reproducible problems and the [TrueFetch community](https://t.me/TrueFetch) for usage questions. Include the run ID, a public input or safe equivalent, expected result and observed message. Keep credentials and private inputs out of public messages.

[Start a small run](https://apify.com/truefetch/reddit-user-profile) | [Open the API reference](https://apify.com/truefetch/reddit-user-profile/api)

**Last Updated:** November 8, 2026

# Actor input Schema

## `username` (type: `string`):

Reddit account to look up. Accepts a plain username, a u/ prefix, or a full profile URL — 'spez', 'u/spez' and 'https://www.reddit.com/user/spez/' all resolve to the same account.

## `max_posts` (type: `integer`):

Maximum authored posts per profile, newest first. Zero skips posts. There is no input ceiling; only available public history is returned, and an unavailable continuation is reported.

## `max_comments` (type: `integer`):

Maximum authored comments per profile, newest first then top for additional distinct comments. Zero skips comments. There is no input ceiling; unavailable history is reported.

## Actor input object example

```json
{
  "username": "nasa",
  "max_posts": 2,
  "max_comments": 2
}
```

# Actor output Schema

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

Reddit profiles with account facts, stored media, and the requested post and comment collections.

# 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 = {
    "username": "nasa",
    "max_posts": 2,
    "max_comments": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/reddit-user-profile").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 = {
    "username": "nasa",
    "max_posts": 2,
    "max_comments": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/reddit-user-profile").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 '{
  "username": "nasa",
  "max_posts": 2,
  "max_comments": 2
}' |
apify call truefetch/reddit-user-profile --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,truefetch/reddit-user-profile"
        }
    }
}
```

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/OFnTh9yMuUwXPZe4e/builds/gGvtP0YjbQNEo7Uye/openapi.json