How do I turn a Reddit discussion into product questions backed by original comments?
To turn a Reddit discussion into product questions, take the post ID from the selected post link, add the t3_ prefix and fetch the comments with reddit.app.fetch_post_comments. Export the saved responses to CSV with exact wording, parent relationships and sources. After review, give the product or content team the actionable questions and the conditions under which each question arises.
For example, if someone says a phone edit did not appear on desktop, record both devices and the order of steps. If a reply adds a version or an offline condition, save the reply with the parent comment before anyone tries to reproduce the issue.
Run a research round
- Select the thread. Start from an existing permalink, or use the community shortlist to choose threads and record selection reasons.
- Read one comment page. Review the post and the returned replies, and save the sources. Decide which questions need replies or additional pages.
- Build the source table. Export comment text, identifiers, reply relationships and available counters. When merging saved pages, keep unique comments separate from repeated observations of the same comment.
- Review excerpts. For each selected comment, record a theme, a verbatim quotation and a review reason. Add the comment to the backlog after the quotation is confirmed in the original response.
- Choose next actions. Sort each issue into one of four groups: already answered in the thread, documentation work, reproduction, or verification.
To hand the review to an assistant connected to BeatAPI, use this instruction:
Review the saved comments for this thread and organize note-sync questions and experiences. Keep original wording, the thread link and parent context. Describe the conditions and verification needed. Give me actionable questions rather than only sentiment labels.
Match files to deliverables
For example, “Which setting supports offline use?” becomes a documentation question. A report of sync failure on one device starts as an experience to reproduce. Comment scores show engagement; a comment score does not establish a defect.
Steps 1–7 below cover retrieval, export, merge and excerpt review. The local steps reuse saved responses and add no charge; estimate new comment or reply retrieval with current pricing.
1. Confirm input and scope
Take the ID after /comments/ in the post URL and prefix the ID with t3_. Replace the syntax sample t3_abc123 with your real ID. Limit the first run to one page. Check the current inputs and price of data:reddit.app.fetch_post_comments with the free /v1/capabilities/inspect endpoint. Each platform call is charged at the current price; local conversion adds no charge.
If you copied a post or comment permalink, use the local request preparer to extract the post ID; the last ID in a comment permalink names a comment, not the post. The preparer writes a first-page request body and does not send the request.
2. Save one raw response
If the HTTP request fails, keep the error and do not export. After an HTTP success, export_comments.py still checks the business status, the action and the tree shape. The request in step 2 reads the direct /v1/social-data/call response, not a capabilities execution wrapper.
3. Export text and reply relationships
Save the script below as export_comments.py and run the script with Python 3. The target CSV must not exist yet: the script checks the response structure before opening the target and never overwrites an existing export. A missing score stays empty, and a zero score stays zero. Text that starts with a formula character gets a leading apostrophe to reduce the risk that a spreadsheet app runs the text as a formula.
4. Check the export and continue deliberately
Check that rows in the printed summary matches the CSV row count, and check for duplicate IDs. A valid empty page produces a header only. When merging pages, keep parent_id and depth and deduplicate by id. permalink is relative: prepend https://www.reddit.com to open the comment. score is not a like count, and missing text stays missing; do not reconstruct missing text.
The script prints has_next_page and after. Stop when has_next_page is false. Continue only when has_next_page is true, after is a new nonempty cursor and the next page fits your approved page budget; save the next page under new JSON and CSV filenames. Stop and inspect the response when the cursor is missing or repeated, the status is missing or the response is an error. The script never retries a paid query.
5. What does this export cover?
The export is a snapshot of the returned comment nodes, not a complete historical backup. A child_count value does not mean that many replies were received. Keep missing parents and removal flags, and do not promote orphan replies to top-level comments while merging. The FAQ linked below gives the exact paging boundaries.
The field paths come from the backend’s four historical production response structures and the gateway’s current renderer. The examples follow the documented structure, and t3_abc123 is a placeholder.
6. Merge saved pages without losing duplicate observations or missing parents
Do not concatenate per-page CSVs and treat the result as deduplicated. Create pages.json with the requested post_id and the actual collection time of each CSV, as in this example manifest:
Save the script below as merge_pages.py and run python3 merge_pages.py pages.json merged-comments. The script runs offline, refuses an existing output directory and writes three files:
comments.csv: one row per post + comment ID, using the first observation in manifest order.observations.csv: every observation, so later edits and score changes are not silently overwritten.coverage.json: pages, unique comments, duplicate observations and replies with missing parents.
A reply whose parent is missing remains a reply, and a valid empty page still counts as a page.
7. Turn the saved discussion into an evidence-backed question backlog
Retrieving comments and interpreting praise, complaints and questions are separate steps. On Reddit, also keep the reply context: a reply to another reader is not automatically an independent product complaint. Use the merged comments from step 6 instead of buying the same pages again.
For a product team, deliver a short list of three kinds of items, each linked to exact evidence: questions to answer, recurring friction to investigate and praise to preserve. Read the thread context and assign at most one primary topic to each included comment. An AI model may propose labels; a reviewer checks every label. Mark ads, off-topic discussion and unsupported interpretation as excluded with a reason. Do not use removed comments, or comments with an unknown removal state, as support.
Create review-labels.json with real post and comment IDs and exact excerpts from the markdown text of the raw response. Replace the placeholders in this template:
For an included comment, set kind to question, complaint or praise. To exclude a comment, set decision to exclude and give a nonempty reason. Save the script below as reddit_review.py. The script checks that each reviewed comment is in the merged sample, that each quote appears verbatim in the raw text and that the comment is explicitly not removed. The script keeps parent and depth context and reports unreviewed comments, so a partial review does not look complete. The script does not check whether a user’s claim is true and does not publish anything.
Before you run the script, save raw-pages.json, which maps each source_csv of the merged table to the raw response and the requested post. CSV formula escaping can add an apostrophe that is not in the source text, so reddit_review.py checks quotes against the raw JSON instead of stripping apostrophes.
Run python3 reddit_review.py merged-comments/comments.csv raw-pages.json review-labels.json question-backlog.json. Read every evidence excerpt in context, then fill proposed_action and verification_needed in a copy. For example, an unanswered setup question leads to a documentation draft, and a complaint leads to a reproduction checklist, not an immediate public accusation. Each proposed action is your editorial decision, not API output.
Counts in question-backlog.json are supporting comments and distinct posts, not distinct people, customer prevalence or independent survey responses. Top-level comments and replies are reported separately, and missing parents stay visible. Excluded and unreviewed counts stay in the coverage record. The output omits author names, but quotes can still contain personal information: redact a shareable copy before you send the quotes outside the review team.
Reject corrupt rows without throwing away a valid missing-cursor page
Before creating the CSV, export_comments.py requires a request ID, an explicit hasNextPage boolean and valid types for comment depth, child count and score. A negative Reddit score is valid; a boolean or fractional score is not accepted as a count. Identical repeated nodes within one page collapse into one row and are counted. Two different versions of the same ID within one page stop the export, so a favorable quote cannot be selected silently; keep the raw response for investigation. The merge step keeps changes between separately saved pages.
When a valid page has comments but no usable next cursor, the exporter still exports those comments and reports missing_usable_cursor; the page has comments, and the thread is not complete. provider_end means only that the comment-list pagination ended. The exporter always sets all_comments_collected to false, because unexpanded reply branches, removed text and later activity are not in the saved pages. next_page_available means a cursor exists; spending on another page is your decision. Continue only within the existing budget and only with a new cursor.
Sign off the backlog before sharing it
For each topic, confirm that the retained excerpts support the label in their thread context. A question points to a documentation gap to investigate, a complaint to a reproduction task and praise to an experience worth preserving. The proposed next steps are editorial judgments, not verified findings about every customer. Fill proposed_action and verification_needed in a reviewed copy, and keep the generated output unchanged.
Deliver these files together: the chosen-thread list with reasons; the original page bytes; the per-page CSVs; pages.json and raw-pages.json; the merged comments and all observations; the review labels; the generated backlog; and the edited action copy. State how many comments remain unreviewed instead of presenting a partially labeled file as fully assessed. Remove personal details from quotes in any shareable copy. The scripts do not contact Reddit users, publish findings, create alerts or grant permission to share the material.
With multiple pages, check by hand that each saved request used the new after cursor from the previous page; merge_pages.py does not validate the cursor chain. Each csv_file in raw-pages.json must exactly match a source_csv value in the merged table.
reddit_review.py also rejects conflicting duplicate IDs within one raw page, unusable non-null nodes and error envelopes, so the review never picks a favorable version. Comment scores must be safe JSON integers, and negative scores remain valid. Keep unexpected values for investigation instead of deriving a precise score from an unsafe number.
Start from chosen community feeds instead of known post links.

