# Automate with AI Reddit Research: Make, OpenAI and Airtable

> You'll build a Make scenario that collects targeted Reddit posts, scores buying intent and pain points with OpenAI, and writes deduplicated rows into Airtable. A human reviews every row before any outreach, so you get research without spam.

- Canonical page: https://syswithai.com/blog/reddit-pain-points-make-openai-airtable/
- Site: syswithai (syswithai.com)
- Format: executable automation workflow
- Published: 2026-11-04
- Last updated: 2026-11-04
- Author: Syswithai
- Citation policy: every data claim links, in the same sentence, to the page it came from. Claims without a source are not published.

If you want to automate with AI Reddit research, the task you're removing is easy to name: someone on your team opens a handful of subreddits every morning, scrolls new posts, copies the ones where a person describes a real problem, pastes them into a spreadsheet, and tries to remember which ones they already saved. Founders do it. Marketers do it. Support leads do it when they're hunting for feature ideas. Done by hand, it drifts fast: the same thread gets logged twice, good posts get skipped on busy days, the "why this matters" note is different every time, and nobody can tell which rows were actually checked before someone reached out. This guide walks you through a Make scenario that pulls targeted Reddit posts, removes duplicates by Reddit ID, has an OpenAI step score intent and [extract](https://syswithai.com/blog/n8n-workflow-automation-templates-invoices/) the pain point into a fixed schema, and writes clean rows into Airtable for a human to review before any outreach happens.

Last updated: November 2026

## Workflow at a glance

| Item | Details |
| --- | --- |
| Problem it solves | Finding Reddit posts where people describe a problem your product or service addresses, without manual scrolling, copy-paste and duplicate rows. |
| Manual steps it replaces | Opening each subreddit, reading new posts, judging whether a post shows buying intent, copying title, link, author and text, writing a summary of the pain point, checking the sheet for duplicates, and tagging the row for follow-up. |
| Trigger | A Make schedule (for example, every morning on weekdays). An optional variant uses the Reddit "Watch New Post or Comment Matching Search" module as the trigger. |
| Output | One Airtable record per qualifying post with Reddit ID, subreddit, title, URL, author, post text, intent score, intent category, pain point summary, suggested angle, and a Review Status of "Needs review". |
| Tools | Make (Reddit app, Data store, HTTP, JSON, Array aggregator, Airtable app), OpenAI Responses API, Airtable. |
| Skill level needed | Comfortable with Make's visual editor and mapping fields. No programming. You'll paste one JSON body and one prompt. |
| Complexity | Medium. Each module is simple, but you're connecting three services, handling structured AI output, and adding error handling for rate limits. |

## What you need before you start

Gather these first. It saves a lot of back-and-forth inside the editor.

- **A Make account.** Any plan that lets you build a scenario with a schedule works for testing. You'll use the Reddit, Data store, HTTP, JSON, Tools, Flow control and Airtable apps.

- **A Reddit account and a registered Reddit developer application.** [Make's Reddit app documentation](https://apps.make.com/reddit?hl=en) says the connection needs an active Reddit account and a registered developer application to obtain OAuth credentials. OAuth is the sign-in method where Reddit gives Make a token instead of your password. Make's Reddit page walks you through creating the app and copying the client ID and secret.

- **Agreement with Reddit's rules.** [Reddit's Data API Wiki](https://support.reddithelp.com/hc/en-us/articles/16160319875092-Reddit-Data-API-Wiki) states that clients using the Data API must authenticate with a registered OAuth token. Read that page for the access terms and the free-access query limit before you schedule anything frequent.

- **An OpenAI API key.** Create it in your OpenAI platform account under API keys, and add a payment method or credits. Store it only in Make's HTTP module or a Make connection, never in a shared doc.

- **An Airtable base and a personal access token.** [Airtable's Web API uses a personal access token in the request header](https://support.airtable.com/articles/7735693959-managing-api-call-limits-in-airtable). Create the token in Airtable's developer hub with the scopes `data.records:read`, `data.records:write` and `schema.bases:read`, and give it access to only the one base you'll use. Airtable's developer hub is where you create and manage tokens.

- **A list of target subreddits.** Pick three to five communities where your audience asks for help. Read each one's rules in the sidebar so you know whether promotional replies are allowed at all.

- **Sample data to test with.** Save five real post URLs: two clear "I need a tool for this" posts, one rant with no buying intent, one off-topic post, and one very long post. You'll use them in the test table later.

Now build the Airtable table. Name it `Reddit Leads` and create these fields exactly, because the mapping later depends on the names:

```
Reddit ID          Single line text   (primary field)
Subreddit          Single line text
Title              Long text
Post URL           URL
Author             Single line text
Post Text          Long text
Posted At          Date (include time, GMT)
Intent Score       Number (integer, 0 decimals)
Intent Category    Single select: buying, seeking_help, complaining, discussion, off_topic
Pain Point         Long text
Suggested Angle    Long text
AI Reason          Long text
Review Status      Single select: Needs review, Approved, Rejected, Contacted
Captured At        Date (include time, GMT)
```

## How the workflow runs

Here's the full path a post takes, with the fields [that](https://syswithai.com/blog/ai-trends-2026-productivity-gains/) move between modules.

1. **Trigger:** Make's scheduler starts the scenario at the time you set.

2. **Collect:** Reddit "List Subreddit Posts" returns new posts from one subreddit. Fields passed on: `id`, `name`, `title`, `selftext`, `author`, `permalink`, `subreddit`, `created_utc`.

3. **Pre-filter (decision point):** a Make filter drops posts with an empty title, deleted authors, or text that doesn't contain any of your keywords. Posts that fail stop here.

4. **Deduplicate (decision point):** Data store "Get a record" looks up the post's `name` (Reddit's full ID, like `t3_abc123`). If a record exists, the filter after it stops the bundle. If not, it continues.

5. **Classify:** HTTP "Make a request" sends `title`, `selftext` and `subreddit` to the OpenAI Responses API with a strict JSON schema. It returns `intent_score`, `intent_category`, `pain_point`, `suggested_angle`, `reason`.

6. **Parse:** JSON "Parse JSON" turns the model's text into mappable fields.

7. **Score gate (decision point):** a filter lets through only bundles with `intent_score` at or above your threshold and a category that isn't `off_topic`.

8. **Remember:** Data store "Add/replace a record" saves the Reddit ID so the post is never classified again, even if the Airtable write fails later.

9. **Batch:** Array aggregator collects the passing bundles into one array of Airtable record objects.

10. **Write:** Airtable "Make an API call" sends one PATCH request that upserts the records, merging on `Reddit ID`.

11. **Output:** new rows appear in `Reddit Leads` with Review Status "Needs review". A person reads them and decides what, if anything, to do.

## Build it step by step

### Step 1: Create the scenario and set the schedule

In Make, click **Create a new scenario**. Name it `Reddit pain points to Airtable`. Click the clock icon on the first module slot and set **Run scenario** to **Days of the week**, pick Monday to Friday, and choose a morning time. Leave it switched off until the tests pass.

Why a schedule and not an instant trigger? A schedule keeps the number of Reddit, OpenAI and Airtable calls predictable. You can switch later.

**Check:** the scheduler icon shows your chosen days and time, and the scenario toggle is still off.

### Step 2: Connect Reddit and list new posts

Add the Reddit app and choose **List Subreddit Posts**, one of the modules listed in [Make's Reddit app documentation](https://apps.make.com/reddit?hl=en). Click **Create a connection**, paste the client ID and secret from your Reddit developer app, and approve access in the pop-up window.

Settings:

- **Subreddit:** one name without the `r/` prefix, for example `smallbusiness`.

- **Sort:** New.

- **Limit:** 10. Small on purpose (it keeps the later Airtable write to a single request).

To cover several subreddits, don't stack five Reddit modules. Put a **Tools > Set variable** module before it holding a comma-separated list, then **Flow control > Iterator** over `{{split(1.subreddits; ",")}}`, and map the iterator value [into](https://syswithai.com/blog/ai-agent-workflow-small-business-slide-generator/) the Subreddit field. Keep the total under ten posts per run at first.

**Check:** click **Run once**. The Reddit module's output bubble shows up to 10 bundles, each with `id`, `name`, `title`, `selftext`, `author` and `permalink`.

### Step 3: Add the keyword pre-filter

Click the line after the Reddit module and choose **Set up a filter**. Label it `Has keywords`. This cheap check stops obvious noise before you pay for an AI call.

Conditions (all joined with AND, except the last group):

```
Condition 1:  {{2.title}}            Text operators: Exists
Condition 2:  {{2.author}}           Text operators: Not equal to   [deleted]
Condition 3 (OR group):
  {{lower(2.title + " " + 2.selftext)}}   Text operators: Contains   looking for
  {{lower(2.title + " " + 2.selftext)}}   Text operators: Contains   any tool
  {{lower(2.title + " " + 2.selftext)}}   Text operators: Contains   how do you
  {{lower(2.title + " " + 2.selftext)}}   Text operators: Contains   recommend
```

Swap the phrases for ones your buyers actually use. In practice, phrases that describe a struggle ("spending hours on", "keeps breaking") beat product category names.

**Check:** run once again. The filter icon shows how many bundles passed. If zero pass, loosen the phrases; if everything passes, tighten them.

### Step 4: Deduplicate with a Make data store

First create the store: in the left menu open **Data stores**, click **Add data store**, name it `reddit_seen`, and create a data structure with two fields: `reddit_id` (Text) and `seen_at` (Date).

Back in the scenario, add **Data store > Get a record**. Choose `reddit_seen` and set **Key** to `{{2.name}}`. Using `name` (which includes the `t3_` type prefix) means a post and a comment can never share a key.

Add a filter after it labelled `Not seen before`:

```
{{4.reddit_id}}    Basic operators: Does not exist
```

Here's the catch: "Get a record" with no match returns an empty bundle rather than an error, which is exactly what this filter relies on.

**Check:** run once twice in a row. The second time, nothing should get past `Not seen before` once Step 8 is in place. For now, confirm the first run passes everything.

### Step 5: Classify each post with the OpenAI Responses API

Add **HTTP > Make a request**. Using the HTTP module instead of a pre[built](https://syswithai.com/blog/best-ai-automation-tools-2026/) AI module gives you strict structured output and keeps the request visible.

- **URL:** `https://api.openai.com/v1/responses`

- **Method:** POST

- **Headers:** `Authorization` = `Bearer YOUR_OPENAI_API_KEY`; `Content-Type` = `application/json`

- **Body type:** Raw, content type JSON (application/json)

- **Parse response:** Yes

- **Timeout:** 60 seconds

Request content (the full prompt text is in the templates section; paste it where shown):

```
{
  "model": "YOUR_MODEL",
  "input": [
    { "role": "system", "content": "PASTE_SYSTEM_PROMPT_HERE" },
    { "role": "user", "content": "Subreddit: r/{{2.subreddit}}\nTitle: {{replace(2.title; "\""; "'")}}\nPost text: {{replace(substring(2.selftext; 0; 4000); "\""; "'")}}\nOffer we are researching: PASTE_ONE_LINE_OFFER" }
  ],
  "text": {
    "format": {
      "type": "json_schema",
      "name": "reddit_intent",
      "strict": true,
      "schema": {
        "type": "object",
        "additionalProperties": false,
        "properties": {
          "intent_score": { "type": "integer", "minimum": 0, "maximum": 10 },
          "intent_category": { "type": "string", "enum": ["buying", "seeking_help", "complaining", "discussion", "off_topic"] },
          "pain_point": { "type": "string" },
          "suggested_angle": { "type": "string" },
          "reason": { "type": "string" }
        },
        "required": ["intent_score", "intent_category", "pain_point", "suggested_angle", "reason"]
      }
    }
  }
}
```

Replace `YOUR_MODEL` with a current model name from [OpenAI's pricing page](https://developers.openai.com/api/docs/pricing); a small, low-cost model is usually enough for classification. The `replace()` calls swap double quotes for single quotes so a quote inside a post can't break the JSON. Line breaks in posts can also break it, so wrap the post text in `{{replace(...; newline; " ")}}` if you see "invalid JSON" errors. The `substring()` call caps very long posts at 4,000 characters, which keeps token use predictable.

**Check:** run once. The HTTP module shows status code 200 and a `data` object containing an `output` array. Inside it you'll find a message item whose `content` holds a `text` value that is a JSON string.

### Step 6: Parse the model's JSON

Add **JSON > Parse JSON**. Click **Add** next to Data structure, choose **Generator**, and paste this sample so Make learns the fields:

```
{"intent_score":7,"intent_category":"seeking_help","pain_point":"Example text","suggested_angle":"Example text","reason":"Example text"}
```

Set **JSON string** to:

```
{{last(map(flatten(map(5.data.output; "content")); "text"))}}
```

That expression pulls every `content` list out of the output items, flattens them, collects the `text` values, and takes the last one, which is the final answer. Some models add other output items first. This handles that.

**Check:** the Parse JSON output shows five separate fields with real values. If you see one long string instead, the data structure wasn't generated; redo the Generator step.

### Step 7: Gate on intent score

Add a filter after Parse JSON labelled `Worth reviewing`:

```
Condition 1:  {{6.intent_score}}      Numeric operators: Greater than or equal to   6
AND
Condition 2:  {{6.intent_category}}   Text operators: Not equal to   off_topic
```

Start at 6. After a week of real rows, raise or lower it based on how many rejected rows your reviewer marks.

**Check:** run once with your sample posts. The rant and the off-topic post should stop here, the two "I need a tool" posts should pass.

### Step 8: Remember every classified post

Here's a subtle point. You want to store the ID of every post you paid to classify, not only the ones that passed. So place this module *before* the `Worth reviewing` filter: right-click the line between Parse JSON and the filter, add **Data store > Add/replace a record**, and set:

- **Data store:** `reddit_seen`

- **Key:** `{{2.name}}`

- **reddit_id:** `{{2.name}}`

- **seen_at:** `{{now}}`

**Check:** open **Data stores > reddit_seen > Browse**. One row per classified post appears. Run once more and confirm the `Not seen before` filter now blocks them.

### Step 9: Build the Airtable records array

After `Worth reviewing`, add **Flow control > Array aggregator**. Set **Source Module** to the Reddit module (or the Iterator, if you used one). Under Target structure type choose **Custom** and add one collection field named `fields` with these keys mapped:

```
Reddit ID        {{2.name}}
Subreddit        {{2.subreddit}}
Title            {{2.title}}
Post URL         https://www.reddit.com{{2.permalink}}
Author           {{2.author}}
Post Text        {{substring(2.selftext; 0; 4000)}}
Posted At        {{formatDate(parseDate(2.created_utc; "X"); "YYYY-MM-DDTHH:mm:ss[Z]")}}
Intent Score     {{6.intent_score}}
Intent Category  {{6.intent_category}}
Pain Point       {{6.pain_point}}
Suggested Angle  {{6.suggested_angle}}
AI Reason        {{6.reason}}
Review Status    Needs review
Captured At      {{now}}
```

The `"X"` token tells Make that `created_utc` is a Unix timestamp in seconds.

**Check:** the aggregator outputs a single bundle with an `Array` containing one item per passing post, each with a `fields` object.

### Step 10: Upsert into Airtable in one request

Add **Airtable > Make an API call** and connect it with your personal access token. [Airtable's batch create and batch update endpoints support up to 10 records per request](https://support.airtable.com/articles/2111090641-airtable-api-common-troubleshooting), which is why Step 2 caps each run at 10 posts.

- **URL:** `/v0/YOUR_BASE_ID/Reddit%20Leads` (the base ID starts with `app` and is visible in the base's URL)

- **Method:** PATCH

- **Headers:** `Content-Type` = `application/json`

- **Body:**

```
{
  "performUpsert": { "fieldsToMergeOn": ["Reddit ID"] },
  "typecast": true,
  "records": {{toString(toJSON(7.array))}}
}
```

`performUpsert` makes Airtable update an existing row with the same Reddit ID instead of creating a second one, a second safety net behind the data store. `typecast` lets Airtable match the single-select text to existing options. If you choose to raise the per-run limit above 10, add a **Repeater** plus `slice()` to send chunks of 10, or simply run the scenario more often.

Add a filter before this module: `{{length(7.array)}}` Numeric: Greater than 0, so empty runs don't call Airtable at all.

**Check:** the module returns status 200 with a `records` array and a `createdRecords` list. The rows appear in Airtable with Review Status "Needs review".

### Step 11: Add error handling and a review view

Right-click the HTTP (OpenAI) module, choose **Add error handler**, and pick **Break**. Turn on **Automatically complete execution**, set attempts to 3 and interval to 5 minutes. Do the same on the Airtable module. In **Scenario settings**, enable **Allow storing of incomplete executions** so failed bundles wait for a retry instead of disappearing.

In Airtable, create a grid view named `To review` filtered on Review Status is "Needs review" and sorted by Intent Score descending. That view is the only place a person should start from.

**Check:** temporarily break your OpenAI key (add a letter), run once, and confirm an incomplete execution appears under the scenario's **Incomplete executions** tab. Fix the key and retry it.

### Step 12: Keep outreach human and consent-aware

Don't connect Airtable to an auto-DM or auto-comment tool. This workflow finds and organizes posts; a person decides whether a reply is welcome, useful and allowed by that subreddit's rules and Reddit's terms. Add an Airtable checkbox field named `Rules checked` and require it before anyone sets Review Status to "Contacted".

**Check:** every row marked "Contacted" also has `Rules checked` ticked. Create a filtered view to spot any that don't.

## Prompts and templates

Paste the system prompt into the `system` content in Step 5. Keep it as one line inside the JSON, or replace line breaks with `\n`.

```
SYSTEM PROMPT

You classify Reddit posts for a market research team. You read one post and decide whether the author is describing a real problem that a product or service could solve.

Rules:
- Judge only what the author wrote. Do not guess their job, company or budget.
- intent_score is an integer from 0 to 10:
  0-2 = no problem described, joke, news, or meme
  3-5 = a problem is mentioned but the author is venting or discussing, not looking for a solution
  6-8 = the author is actively asking for advice, tools, or ways to fix the problem
  9-10 = the author explicitly asks for a tool, service, or recommendation to pay for
- intent_category must be one of: buying, seeking_help, complaining, discussion, off_topic.
- Use off_topic when the post has nothing to do with the offer described in the user message.
- pain_point: one or two plain sentences describing the problem in the author's terms. No marketing words.
- suggested_angle: one sentence on how a helpful, non-salesy reply could add value. If no reply is appropriate, write "No reply recommended".
- reason: one sentence explaining the score, quoting a short phrase from the post.
- Never invent details that are not in the post.
- Return only the JSON object required by the schema.
```

```
USER PROMPT TEMPLATE

Subreddit: r/{subreddit}
Title: {title}
Post text: {selftext_first_4000_chars}
Offer we are researching: {one_line_description_of_your_offer}
```

```
EXPECTED OUTPUT SCHEMA

{
  "intent_score": integer 0-10,
  "intent_category": "buying" | "seeking_help" | "complaining" | "discussion" | "off_topic",
  "pain_point": string,
  "suggested_angle": string,
  "reason": string
}

Example output (example data, not a real post):
{
  "intent_score": 7,
  "intent_category": "seeking_help",
  "pain_point": "The author copies invoice totals from email into a spreadsheet by hand every week and keeps making typos.",
  "suggested_angle": "Share a short explanation of how to pull invoice fields from email automatically, without linking a product.",
  "reason": "The author asks 'is there any way to stop doing this by hand'."
}
```

```
AIRTABLE UPSERT BODY (Step 10)

{
  "performUpsert": { "fieldsToMergeOn": ["Reddit ID"] },
  "typecast": true,
  "records": [
    { "fields": { "Reddit ID": "t3_example1", "Title": "...", "Review Status": "Needs review" } }
  ]
}
```

## Test it before you trust it

Run each case with **Run once** and compare against the expected result. You can feed a specific post by temporarily replacing the Reddit module with **Reddit > Make an API call** pointed at that post, or by pasting values into a **Tools > Set multiple variables** module.

| Test input | Expected output |
| --- | --- |
| A post explicitly asking for a tool recommendation that matches your offer | intent_score 9 or 10, category buying, one new Airtable row with Review Status "Needs review" |
| A post asking how others handle the problem, no tool requested | intent_score 6 to 8, category seeking_help, one new row |
| A rant about the problem with no question | intent_score 3 to 5, category complaining, Reddit ID saved in data store, no Airtable row |
| An off-topic post that happens to contain a keyword | category off_topic, no Airtable row |
| Empty input: subreddit with no new posts, or all posts filtered out | Scenario finishes without errors; Airtable module is skipped by the length filter; no API call made |
| Duplicate: run the same posts twice | Second run stops at "Not seen before"; no new OpenAI calls; no new Airtable rows |
| Duplicate that slips past the data store (delete its data store entry, rerun) | Airtable upsert updates the existing row instead of creating a second one |
| Malformed data: post containing double quotes, emoji and line breaks | HTTP request still returns 200; Parse JSON succeeds; text appears intact in Airtable apart from quotes swapped to single quotes |
| Image or link post with empty selftext | Classification uses the title only; usually scores low; no crash |
| Very large input: a post longer than 4,000 characters | Text truncated by substring() in both the prompt and Airtable; request succeeds |
| Deleted author | Stopped by the "Has keywords" filter |
| Invalid OpenAI key | Break handler stores an incomplete execution; no Airtable write; data store not updated for that bundle |

Only switch the scenario on when every row matches. Then check the `To review` view daily for the first week.

## Where it breaks and how to fix it

Most failures fall into five buckets. Each one has a clear symptom.

- **Auth expiry.** Symptom: the Reddit module or Airtable module fails with 401 or "invalid token". Fix: open **Connections** in Make and reauthorize the Reddit connection; for Airtable, check that the personal access token wasn't revoked and still has access to the base. [Reddit requires a registered OAuth token for Data API clients](https://support.reddithelp.com/hc/en-us/articles/16160319875092-Reddit-Data-API-Wiki), so a deleted developer app also kills the connection.

- **Rate limits.** Symptom: HTTP 429 from Airtable, OpenAI or Reddit. Fix: the Break handler retries after a delay. [Airtable recommends exponential backoff with jitter after a 429 response and notes that running out of monthly API calls is a separate cause of 429 errors](https://support.airtable.com/articles/2111090641-airtable-api-common-troubleshooting), so if retries keep failing, check your workspace's monthly usage. Confirm per-base limits on [Airtable's Web API rate limits page](https://airtable.com/developers/web/api/rate-limits), OpenAI limits on [OpenAI's rate limits guide](https://developers.openai.com/api/docs/guides/rate-limits), and Reddit limits on [Reddit's rate limits documentation](https://docs.redditapis.com/docs/rate-limits).

- **Schema drift.** Symptom: Airtable returns 422 "Unknown field name" or a single select rejects a value. Fix: someone renamed a field. Compare the names in Step 9 with the table exactly, including spaces and capitals. Keep `typecast` on for select fields.

- **LLM output errors.** Symptom: Parse JSON fails, or fields come back empty. Fix: confirm `"strict": true` is still in the request and the schema lists all five required fields. If the model name was retired, the HTTP module returns a 404 or 400 naming the model; pick a current one. If the input JSON was malformed, the error mentions the request body; strip line breaks from `selftext`.

- **Duplicate runs.** Symptom: the same post shows up twice. Fix: check that the data store "Add/replace" sits before the score filter, that the key is `name` (not `id` in one place and `name` in another), and that the Airtable call still includes `performUpsert`. Avoid running the scenario manually while a scheduled run is in progress.

## Running costs and limits

Costs come from four places. Watch each one.

- **Airtable API calls.** Airtable's Free plan allows 1,000 API calls per workspace per month, while its Team plan allows 100,000. Batching up to 10 records per call, plus the empty-run filter, keeps this scenario's usage to at most one write call per run.

- **OpenAI tokens.** [OpenAI's Responses API is not priced separately; usage is billed at the selected model's input and output token rates](https://developers.openai.com/api/docs/pricing). Your cost drivers are the number of posts classified, the length of each post (capped at 4,000 characters here), and the model you pick.

- **OpenAI usage tiers.** [OpenAI documents usage limits by tier, including a Build tier with a $500/month usage limit](https://developers.openai.com/api/docs/guides/rate-limits). Set a monthly budget alert in your OpenAI account so a runaway loop can't surprise you.

- **Make operations and Reddit access.** Every module that processes a bundle uses Make operations, so the drivers are runs per day, posts per run and the number of modules. Check your plan's allowance inside your Make account. For Reddit, the free-access query limit is stated on [Reddit's Data API Wiki](https://support.reddithelp.com/hc/en-us/articles/16160319875092-Reddit-Data-API-Wiki); a once-a-day schedule stays far from it in most setups.

## Variations and extensions

- **Scan comments too.** After the score gate, add Reddit's **List Comments in a Post** module, which [Make lists alongside List Subreddit Posts and Watch New Post or Comment Matching Search](https://apps.make.com/reddit?hl=en). Send each comment through the same classifier and store it with its `t1_` name.

- **Search-based trigger.** Replace the schedule and List Subreddit Posts with Watch New Post or Comment Matching Search, using a query like your problem phrase. Good for niche terms spread across many communities.

- **Product research instead of leads.** Change the offer line to a feature you're considering and add a `feature_request` category. Product teams get a ranked list of real complaints.

- **Support team early warning.** Point it at your own product's subreddit, add a `bug_report` category, and route high scores to a Slack channel with Make's Slack app.

- **Swap the stack.** The same logic runs in n8n (Reddit node, Code node for dedupe, HTTP Request to OpenAI, Airtable node) or Zapier. The data store, strict schema and upsert pattern carry over directly.

## Hand this to ChatGPT or Claude

You can paste the brief below, or this page's link, into an AI assistant and ask it to adapt the build to your tools, subreddits and offer.

```
GOAL
Collect new Reddit posts from chosen subreddits, skip duplicates, classify buying intent and pain point with an LLM using a strict JSON schema, and upsert qualifying posts into Airtable for human review. No automatic outreach.

TRIGGER
Make scheduler, weekdays, once each morning.

STEPS
1. Tools > Set variable: subreddits (comma-separated). Flow control > Iterator over split(subreddits; ",").
2. Reddit > List Subreddit Posts: subreddit = iterator value, sort = new, limit = 10 total per run.
3. Filter "Has keywords": title exists, author not [deleted], lowercased title+selftext contains any keyword phrase.
4. Data store > Get a record: store reddit_seen, key = post name (t3_ id). Filter: reddit_id does not exist.
5. HTTP > Make a request: POST https://api.openai.com/v1/responses, bearer API key, body with system prompt, user prompt, text.format json_schema strict with fields intent_score, intent_category, pain_point, suggested_angle, reason. selftext truncated to 4000 chars, quotes and newlines sanitized.
6. JSON > Parse JSON on last(map(flatten(map(data.output; "content")); "text")).
7. Data store > Add/replace a record: key = post name, seen_at = now (before the score filter).
8. Filter "Worth reviewing": intent_score >= 6 and intent_category != off_topic.
9. Flow control > Array aggregator: build records [{fields:{...}}].
10. Filter: array length > 0. Airtable > Make an API call: PATCH /v0/BASE_ID/Reddit%20Leads with performUpsert fieldsToMergeOn ["Reddit ID"], typecast true, records array (max 10).
11. Break error handlers on HTTP and Airtable modules: 3 attempts, 5 minute interval; store incomplete executions.

DATA FIELDS
Reddit ID, Subreddit, Title, Post URL, Author, Post Text, Posted At, Intent Score, Intent Category, Pain Point, Suggested Angle, AI Reason, Review Status, Captured At, Rules checked.

PROMPTS
Use the system prompt and user prompt template from the guide: 0-10 intent scale, five categories, plain-language pain point, one-sentence non-salesy angle or "No reply recommended", one-sentence reason quoting the post, no invented details.

ACCEPTANCE TESTS
Explicit tool request scores 9-10 and creates a row. Rant scores 3-5 and creates no row. Off-topic post creates no row. Second run on same posts makes no OpenAI calls and no rows. Post with quotes, emoji and newlines processes without errors. Post over 4000 chars is truncated and succeeds. Empty run makes no Airtable call. Invalid API key produces an incomplete execution.

CONSTRAINTS
Max 10 posts per run. Human review before any contact. Respect each subreddit's rules and Reddit's Data API terms. Store API keys only in Make connections or module headers.
```

## Frequently Asked Questions

### Can I build this without the Reddit API?

Not reliably. Make's Reddit modules go through the API, and [Reddit requires Data API clients to authenticate with a registered OAuth token](https://support.reddithelp.com/hc/en-us/articles/16160319875092-Reddit-Data-API-Wiki). Scraping pages directly breaks often and can conflict with Reddit's terms, so the registered app route is the one to use.

### Why use the HTTP module instead of Make's OpenAI app?

The HTTP module lets you send the strict JSON schema exactly as OpenAI documents it, and you can see every byte of the request when debugging. If Make's OpenAI app offers structured output in your account, you can switch to it and keep the same prompt and schema.

### What if I want posts from more than 10 subreddits?

Keep each run small and run more often, or chunk the aggregated array into groups of 10 before the Airtable call. The data store keeps duplicates out either way.

### Should the automation reply to posts or DM users?

No. This build stops at a review queue on purpose. Unsolicited automated messages can break subreddit rules and Reddit's terms, and they rarely help anyone. A person should read the post, tick `Rules checked`, and write any reply themselves.

### How do I stop the AI from scoring everything high?

Make the offer line in the user prompt specific, keep the scale definitions in the system prompt, and review the AI Reason field for rows you reject. If one subreddit floods you with high scores, tighten that subreddit's keywords rather than the prompt.

### Where do I check the exact limits for my plans?

Airtable's limits are on its [API call limits help page](https://support.airtable.com/articles/7735693959-managing-api-call-limits-in-airtable), OpenAI's on its [rate limits guide](https://developers.openai.com/api/docs/guides/rate-limits), and Reddit's on its [Data API Wiki](https://support.reddithelp.com/hc/en-us/articles/16160319875092-Reddit-Data-API-Wiki). Make shows your operations allowance in your organization's subscription settings.

## Your first step

Today, create the `Reddit Leads` table in Airtable with the exact field names above and register your Reddit developer app. With those two pieces in place, the Make scenario takes one focused session to build and test.

## Related Articles

- [n8n Workflow Automation Templates: Extract Invoice Data to Sheets](https://syswithai.com/blog/n8n-workflow-automation-templates-invoices/)

- [Ai Agent Workflow for Small Business: Turn Notes into Slide Decks](https://syswithai.com/blog/ai-agent-workflow-small-business-slide-generator/)

- [Automate Business Lead Routing with Zapier and OpenAI](https://syswithai.com/blog/automate-business-lead-routing-zapier-openai/)

- [Best AI Automation Tools Cut Manual Work When Built Right](https://syswithai.com/blog/best-ai-automation-tools-2026/)

- [Back to Home](https://syswithai.com/)

## Sources

- [Managing API call limits in Airtable](https://support.airtable.com/articles/7735693959-managing-api-call-limits-in-airtable)

- [reddit - Apps Documentation](https://apps.make.com/reddit?hl=en)

- [Pricing | OpenAI API](https://developers.openai.com/api/docs/pricing)

- [Reddit Data API Wiki - Reddit Help](https://support.reddithelp.com/hc/en-us/articles/16160319875092-Reddit-Data-API-Wiki)

- [Rate limits | Reddit API](https://docs.redditapis.com/docs/rate-limits)

- [Web API rate limits](https://airtable.com/developers/web/api/rate-limits)

- [Airtable API | API Explorer - Requestly](https://requestly.com/api-explorer/airtable/)
