> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.beatapi.io/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.beatapi.io/_mcp/server.

# How do I select useful Reddit product discussions before reading comments?

> Choose communities for a product question, review new posts and record selection reasons before spending comment retrieval on relevant threads.

To find Reddit discussions worth reading, pick two communities that match your product question and fetch one page of newest posts from each community with `reddit.app.fetch_subreddit_feed` and `sort:"NEW"`. Record why each candidate post fits the question, then select up to three posts for comment review. If you already have a post link, go straight to [comment review](/guides/reddit-comment-export).

For note-sync research, prefer posts that name a device, an action and an outcome. “My desktop does not show edits I made on my phone” gives you more to investigate than a title that only mentions sync.

## What makes a discussion worth selecting?

| Clue                                               | Possible selection reason                                                     |
| -------------------------------------------------- | ----------------------------------------------------------------------------- |
| A specific multi-device conflict after offline use | Concrete conditions worth checking against replies and explanations           |
| A question about choosing sync settings            | A chance to understand unclear instructions                                   |
| A comparison of two workflows with tradeoffs       | Useful decision conditions requiring context                                  |
| A vague complaint or praise in the title           | Mark as pending until the post or its discussion shows a real usage situation |

Use scores and comment counts to decide reading order, and write each selection reason as the research question the thread helps answer. A relevant low-score post can still be useful; a high score does not establish a customer problem.

## Read the outputs

`posts.csv` lists the candidate posts. `sources.json` and `coverage.json` record where each saved page came from and what the pages cover. After you add chosen native post IDs and reasons, `prepare_reddit_threads.py` writes `selected-comment-requests.json`, the plan for comment retrieval.

To hand the shortlist to an assistant connected to BeatAPI, use this instruction:

> Review the NEW pages of these two relevant communities for note-sync discussions. Select at most three threads, explaining the usage context and why comments are worth reading. Keep identifiers and sources. Deliver the shortlist before reading the selected discussions.

Steps 1–5 below retrieve the feed pages, build the candidate list, record selection reasons and hand the selected posts to the comment workflow. Building the list runs locally. Write research conclusions after you review the comment evidence.

## 1. Define community and budget before collecting

Record the product task and why each chosen community is relevant. Request `reddit.app.fetch_subreddit_feed` with `subreddit_name` without `r/`, `sort` NEW, `language` en-US and `need_format` false. The community feed is not a keyword search. The feed input has no time-range field, so do not label a NEW page as all-time or this-year top posts.

Two feed pages plus up to three comment pages make at most five planned data requests. Estimate the cost with current [pricing](https://beatapi.io/pricing); additional pages, replies and model analysis are separate. Reuse saved responses. To see the current inputs and price of `data:reddit.app.fetch_subreddit_feed`, call the free Inspect endpoint:

```bash
curl -sS https://api.beatapi.io/v1/capabilities/inspect \
  -H 'Content-Type: application/json' \
  -d '{"reference":"data:reddit.app.fetch_subreddit_feed"}'
```

## 2. Save a first-page response with its original parameters

Replace `SaaS` with your selected community, and judge relevance from the community's posts, not from the community name alone. Save the request as `request-feed.json`:

```json
{"action":"reddit.app.fetch_subreddit_feed","params":{"subreddit_name":"SaaS","sort":"NEW","language":"en-US","need_format":false}}
```

After you approve the cost, send the request and save the headers and response:

```bash
mkdir reddit-feed-1 &&
curl --fail-with-body -sS https://api.beatapi.io/v1/social-data/call \
  -H "Authorization: Bearer $BEATAPI_API_KEY" \
  -H 'Content-Type: application/json' \
  --data-binary @request-feed.json \
  -D reddit-feed-1/headers.txt \
  -o reddit-feed-1/response.json
```

Keep the HTTP status, the request file and the actual collection time. Use a separate request file and directory for the second community. A failed response is not an empty feed: do not retry automatically and do not add pages. If you already have the saved pages, skip this step.

## 3. Export the saved feed without guessing fields

In the saved response, posts are in `data.subredditV3.elements.edges`. One post's title, author, creation time, score and comment count can sit in different `node.cells` entries. `prepare_reddit_threads.py` joins only those five fields, rejects conflicting cell values, keeps missing values and negative scores, and excludes elements whose `adPayload` is not null. Only native `t3_` IDs become selectable posts; the script counts other element IDs as unusable instead of converting the element IDs into invented post IDs.

Create `feed-inputs.json` from the exact request parameters and the actual collection time, and replace the example time with your recorded value. Leave `selected` empty on the first run:

```json
{"snapshots":[{"params":{"subreddit_name":"SaaS","sort":"NEW","language":"en-US","need_format":false},"file":"reddit-feed-1/response.json","collected_at":"2026-11-16T10:00:00Z"}],"selected":[]}
```

Save the script below as `prepare_reddit_threads.py` and run `python3 prepare_reddit_threads.py feed-inputs.json feed-review`. The script writes `posts.csv`, `sources.json`, `coverage.json`, `raw-N.json` and an empty `selected-comment-requests.json`, and makes no network call.

```python
import csv,datetime,hashlib,json,pathlib,re,sys
manifest_file,output=map(pathlib.Path,sys.argv[1:3])
manifest=json.loads(manifest_file.read_text(encoding="utf-8"))
snapshots=manifest.get("snapshots");selected=manifest.get("selected",[])
if not isinstance(snapshots,list) or not snapshots or not isinstance(selected,list) or len(selected)>3:raise ValueError("Provide saved snapshots and at most three selected posts")
rows=[];posts={};sources=[];communities=set();requests=set();stats={"ad_elements":0,"unusable_elements":0,"duplicate_posts":0}
for snapshot in snapshots:
    params=snapshot["params"]
    if not isinstance(params,dict) or set(params)-{"subreddit_name","sort","language","need_format","after"}:raise ValueError("Unsupported feed parameter")
    community=params.get("subreddit_name")
    if not isinstance(community,str) or not re.fullmatch(r"[A-Za-z0-9_]{2,21}",community) or community.lower() in communities:raise ValueError("One saved first page per distinct community")
    if params.get("sort")!="NEW" or params.get("need_format") is not False or params.get("language")!="en-US" or params.get("after","")!="":raise ValueError("Use this workflow's raw NEW first-page scope")
    communities.add(community.lower())
    stamp=snapshot["collected_at"];dt=datetime.datetime.fromisoformat(stamp.replace("Z","+00:00"))
    if dt.tzinfo is None:raise ValueError("Collection time needs timezone")
    source=pathlib.Path(snapshot["file"])
    if not source.is_absolute():source=manifest_file.parent/source
    raw=source.read_bytes();response=json.loads(raw)
    if not isinstance(response,dict) or response.get("status")!="succeeded" or response.get("action")!="reddit.app.fetch_subreddit_feed" or response.get("error") is not None:raise ValueError("Expected successful raw subreddit feed")
    rid=response.get("request_id")
    if not isinstance(rid,str) or not rid.strip() or rid in requests:raise ValueError("Distinct real request IDs required")
    requests.add(rid)
    elements=response["data"]["subredditV3"]["elements"];edges=elements.get("edges")
    if not isinstance(edges,list):raise ValueError("Missing feed edges is not an empty page")
    digest=hashlib.sha256(raw).hexdigest();saved="raw-"+str(len(sources)+1)+".json"
    sources.append({"saved_file":saved,"source_file":str(source.resolve()),"params":params,"collected_at":stamp,"request_id":rid,"sha256":digest,"bytes":raw})
    page_posts={}
    for position,edge in enumerate(edges,1):
        if not isinstance(edge,dict):raise ValueError("Invalid feed edge")
        node=edge.get("node")
        if node is None:stats["unusable_elements"]+=1;continue
        if not isinstance(node,dict):raise ValueError("Unusable non-null feed node")
        if node.get("adPayload") is not None:stats["ad_elements"]+=1;continue
        ident=node.get("id")
        if not isinstance(ident,str) or not re.fullmatch(r"t3_[a-z0-9]{1,17}",ident):stats["unusable_elements"]+=1;continue
        cells=node.get("cells")
        if not isinstance(cells,list):raise ValueError("Post fields require cells array")
        values={}
        for cell in cells:
            if not isinstance(cell,dict):raise ValueError("Invalid post cell")
            for field in ("title","authorName","createdAt","score","commentCount"):
                value=cell.get(field)
                if value is None:continue
                if field in ("score","commentCount"):
                    if type(value) is not int or abs(value)>9007199254740991 or (field=="commentCount" and value<0):raise ValueError("Invalid or unsafe post count")
                elif not isinstance(value,str):raise ValueError("Invalid post text")
                if field in values and values[field]!=value:raise ValueError("Conflicting values across cells")
                values[field]=value
        row={"post_id":ident,"source_community":community,"response_position":position,"title":values.get("title"),"author":values.get("authorName"),"created_at":values.get("createdAt"),"score":values.get("score"),"comment_count":values.get("commentCount"),"post_link":"https://www.reddit.com/comments/"+ident[3:]+"/","request_id":rid,"collected_at":stamp,"source_sha256":digest}
        projection={k:row[k] for k in ("title","author","created_at","score","comment_count")}
        if ident in page_posts and page_posts[ident]!=projection:raise ValueError("Conflicting duplicate post in one page")
        page_posts[ident]=projection
        if ident in posts:
            stats["duplicate_posts"]+=1
            continue
        posts[ident]=row;rows.append(row)
plans=[];chosen=set()
for selection in selected:
    ident=selection.get("post_id");reason=selection.get("reason")
    if ident not in posts or ident in chosen or not isinstance(reason,str) or not reason.strip():raise ValueError("Select a real unique exported post with a review reason")
    chosen.add(ident);row=posts[ident]
    plans.append({"action":"reddit.app.fetch_post_comments","params":{"post_id":ident,"sort_type":"NEW","need_format":False,"after":"","language":"en-US"},"reason":reason,"source_request_id":row["request_id"],"source_sha256":row["source_sha256"],"executed":False})
output.mkdir()
for item in sources:(output/item["saved_file"]).write_bytes(item["bytes"])
(output/"sources.json").write_text(json.dumps([{k:v for k,v in item.items() if k!="bytes"} for item in sources],ensure_ascii=False,indent=2),encoding="utf-8")
(output/"selected-comment-requests.json").write_text(json.dumps(plans,ensure_ascii=False,indent=2),encoding="utf-8")
columns=["post_id","source_community","response_position","title","author","created_at","score","comment_count","post_link","request_id","collected_at","source_sha256"]
with (output/"posts.csv").open("x",encoding="utf-8-sig",newline="") as handle:
    writer=csv.DictWriter(handle,fieldnames=columns);writer.writeheader()
    for row in rows:writer.writerow({k:("'"+v if isinstance(v,str) and (v.lstrip().startswith(("=","+","-","@")) or v.startswith(("\t","\r","\n"))) else v) for k,v in row.items()})
(output/"coverage.json").write_text(json.dumps({"saved_communities":len(communities),"exported_posts":len(rows),**stats,"selected_comment_calls":len(plans),"executed_calls":0,"scope":"Saved NEW first pages only; no time-window ranking or full-community coverage"},indent=2),encoding="utf-8")
print(str(output))
```

## 4. Select evidence-bearing discussions, not just high scores

Read each title and open the generated post link to check the context. Select posts about the product task itself, not every post that mentions the brand name. In `posts.csv`:

* `score` is not a customer count.
* `post_link` is a canonical link built from the native post ID, not a permalink returned by the API.
* `response_position` is the order in the feed, not an official score rank.
* `source_community` records the community the post was retrieved from, not a verified author affiliation.

Copy the manifest, add up to three exported post IDs with nonempty selection reasons to `selected`, and run the script again into a new directory. The entry below shows the syntax:

```json
{"selected": [{"post_id":"t3_REPLACE_WITH_REAL_ID","reason":"Actual reason this thread addresses the product task"}]}
```

Replace the placeholder with a real exported ID; the script rejects the placeholder. The script also rejects IDs that are not in `posts.csv`, duplicate selections and more than three selections. A community that returns no usable posts stays recorded in `sources.json` and `coverage.json`; an empty result is not a reason to buy more pages. Check why elements were excluded before you draw conclusions.

## 5. Move selected requests into the comment-evidence workflow

Each entry in `selected-comment-requests.json` is an unsent request plan that carries the source request ID, the source hash and the selection reason. After you approve a request, send only the entry's `action` and `params` as the API body; the reason and provenance fields stay local.

Save each comment response in its own file, then run `export_comments.py`, `merge_pages.py` and `reddit_review.py` from the [complete comment guide](/guides/reddit-comment-export). The three scripts keep quote evidence, missing parents, removal status and reviewed/unreviewed coverage, and produce `question-backlog.json`. Read the conversation before you label a comment as a complaint, question or praise; a title alone does not establish a pain point.

`prepare_reddit_threads.py` handles one saved first page per community; the script does not follow `endCursor` and does not set up monitoring. When the same post ID appears twice, `posts.csv` keeps the first observation and every source snapshot stays saved. The hashes identify local bytes; the hashes do not prove server authenticity or the accuracy of recorded times. Hand over the original fields, the query scope, the selection reasons and the later comment evidence together for the final review.

## How can I select top discussions across all time or the past year?

To find long-running community discussions, request a TOP sample with `reddit.app.fetch_subreddit_post_channels`, an action separate from the NEW feed:

```json
{"action":"reddit.app.fetch_subreddit_post_channels","params":{"subreddit_name":"SaaS","sort":"TOP","range":"ALL","language":"en-US","need_format":false}}
```

`ALL` covers all time and `YEAR` covers the platform's year window. For a calendar-year study, filter by each post's publication date and report the date filter. `reddit.app.fetch_subreddit_post_channels` has no public continuation input and no fixed output contract, so check whether the response contains identifiable posts and scores. Save TOP responses separately from the NEW feed pages that `prepare_reddit_threads.py` handles. For confirmed posts, continue with the [comment workflow](/guides/reddit-comment-export).