Build a Reddit AI Drafting & ClickUp Review System with n8n (Free

Engaging with potential customers on Reddit requires constant monitoring, thoughtful responses, and careful brand management. Manual Reddit engagement doesn't scale. This n8n workflow automates the entire process: it monitors target subreddits, generates AI-drafted replies using OpenAI, creates review tasks in ClickUp, and posts approved responses back to Reddit—all without manual intervention until the approval step.

You'll learn how to build a complete Reddit automation system that saves 10-15 hours per week while maintaining quality control over every public response.

The Problem: Reddit Engagement That Doesn't Scale

Current challenges:

Manually checking multiple subreddits daily for relevant posts wastes 2-3 hours
Crafting thoughtful, non-promotional replies for each post takes 15-20 minutes per response
Missing time-sensitive posts means lost engagement opportunities (Reddit posts get 80% of engagement in the first 24 hours)
No systematic review process leads to off-brand or overly promotional responses
Tracking which posts you've responded to requires spreadsheets or memory

Business impact:

Time spent: 10-15 hours per week on Reddit monitoring and engagement
Opportunity cost: Missing 60-70% of relevant posts due to manual monitoring gaps
Brand risk: Inconsistent response quality without a review process

Manual Reddit engagement forces you to choose between scale (responding to many posts with lower quality) and quality (fewer, better responses). This workflow eliminates that tradeoff.

The Solution Overview

This n8n workflow creates an end-to-end Reddit engagement system with three core components: RSS-based subreddit monitoring, OpenAI-powered draft generation with keyword filtering, and ClickUp task management for human review. The system monitors target subreddits every 15 minutes, filters posts by relevance, generates contextual draft replies, creates approval tasks, and posts approved responses back to Reddit.

The workflow uses Reddit's RSS feeds (no API authentication required for reading), OpenAI's GPT models for draft generation, ClickUp's API for task management, and Reddit's OAuth API for posting comments. Each component runs independently, creating a resilient system that continues working even if one service experiences issues.

What You'll Build

Component	Technology	Purpose
Subreddit Monitor	RSS Feed Parser + Schedule Trigger	Check target subreddits every 15 minutes for new posts
Relevance Filter	n8n Filter Node + Keyword Matching	Only process posts matching business-relevant keywords
Draft Generator	OpenAI GPT-4 API	Create helpful, non-promotional reply drafts
Review System	ClickUp API	Create tasks with post context and AI draft for approval
Comment Poster	Reddit OAuth API + Webhook Trigger	Post approved replies and update task status
Duplicate Prevention	n8n Set Node + Memory	Track processed posts to avoid duplicate responses

Key capabilities:

Monitor 3-10 subreddits simultaneously (e.g., r/moving, r/Homeowners, r/relocation)
Filter posts by title and body content using customizable keyword lists
Generate contextual draft replies that match your brand voice
Route drafts to ClickUp with full post context for human review
Edit drafts directly in ClickUp before approval
Automatically post approved replies to Reddit
Log all posted comments with URLs for tracking
Skip irrelevant or inappropriate posts automatically

Prerequisites

Before starting, ensure you have:

n8n instance (cloud or self-hosted version 1.0+)
Reddit account with Developer App created (script type)
OpenAI API account with GPT-4 access
ClickUp workspace with API access
ClickUp custom fields configured: Reddit Post URL, Reddit Post ID, AI Draft Reply
Basic understanding of OAuth flows
Reddit API credentials: Client ID, Client Secret, Username, Password

Reddit Developer App setup:

Go to https://www.reddit.com/prefs/apps
Click "Create App" or "Create Another App"
Select "script" as the app type
Set redirect URI to http://localhost:8080 (required but unused)
Save your Client ID and Client Secret

Step 1: Configure Subreddit Monitoring

The workflow begins by monitoring target subreddits using RSS feeds, which don't require Reddit API authentication and avoid rate limiting issues.

Set up the Schedule Trigger:

Add a Schedule Trigger node
Set interval to 15 minutes (balance between responsiveness and API courtesy)
Configure timezone to match your business hours

Configure RSS Feed Parser:

{
  "url": "https://www.reddit.com/r/{{$json.subreddit}}/new.rss",
  "options": {
    "limit": 25
  }
}

Add subreddit list:

Create a Set node with your target subreddits:

{
  "subreddits": [
    "moving",
    "Homeowners", 
    "relocation",
    "RealEstate",
    "FirstTimeHomeBuyer"
  ]
}

Why this works:
Reddit's RSS feeds provide the last 25 posts in reverse chronological order. By checking every 15 minutes, you capture posts within 30 minutes of posting—the critical engagement window. RSS feeds don't count against Reddit's API rate limits, making this approach more stable than direct API polling.

Loop through subreddits:

Use a Loop Over Items node to process each subreddit separately. This prevents one slow subreddit from blocking others and makes debugging easier.

Step 2: Filter for Relevant Posts

Not every post in your target subreddits requires a response. Keyword filtering ensures you only process relevant content.

Configure the Filter Node:

{
  "conditions": {
    "combinator": "or",
    "conditions": [
      {
        "leftValue": "={{ $json.title.toLowerCase() }}",
        "rightValue": "moving to",
        "operator": "contains"
      },
      {
        "leftValue": "={{ $json.title.toLowerCase() }}",
        "rightValue": "relocating",
        "operator": "contains"
      },
      {
        "leftValue": "={{ $json.content.toLowerCase() }}",
        "rightValue": "homeowner",
        "operator": "contains"
      },
      {
        "leftValue": "={{ $json.content.toLowerCase() }}",
        "rightValue": "neighborhood",
        "operator": "contains"
      }
    ]
  }
}

Add duplicate prevention:

Use a Set node to track processed post IDs:

{
  "processedPosts": "={{ $('Workflow').item.json.processedPosts || [] }}",
  "currentPostId": "={{ $json.id }}"
}

Then add a Filter node:

{
  "conditions": {
    "string": [
      {
        "value1": "={{ $json.processedPosts.includes($json.currentPostId) }}",
        "operation": "equals",
        "value2": "false"
      }
    ]
  }
}

Why this approach:
The "or" combinator allows posts matching any keyword to pass through. Checking both title and content captures posts where the key information appears in the body. Converting to lowercase prevents missing posts due to capitalization variations. The duplicate prevention system uses n8n's workflow static data to maintain a list of processed post IDs across executions.

Customize keyword lists:

Create separate keyword arrays for different intent types:

Location keywords: "moving to", "relocating to", "new to"
Problem keywords: "need help", "looking for", "recommendations"
Stage keywords: "homeowner", "first time buyer", "just bought"

This structure makes it easy to adjust filtering logic without rebuilding the entire condition set.

Step 3: Generate AI Draft Replies

OpenAI generates contextual, helpful draft replies that match your brand voice and avoid promotional language.

Configure OpenAI Node:

{
  "resource": "text",
  "operation": "message",
  "model": "gpt-4",
  "messages": {
    "values": [
      {
        "role": "system",
        "content": "You are a helpful community member providing genuine advice about moving and homeownership. Never promote products or services. If the post is spam, off-topic, or inappropriate, respond with exactly 'SKIP'. Otherwise, provide a brief (2-3 sentences), friendly reply that adds value to the conversation."
      },
      {
        "role": "user", 
        "content": "Post Title: {{ $json.title }}

Post Content: {{ $json.content }}

Draft a helpful reply."
      }
    ]
  },
  "options": {
    "temperature": 0.7,
    "maxTokens": 150
  }
}

Add skip logic:

After the OpenAI node, add a Filter node:

{
  "conditions": {
    "string": [
      {
        "value1": "={{ $json.choices[0].message.content.trim() }}",
        "operation": "notEquals",
        "value2": "SKIP"
      }
    ]
  }
}

Why this works:
GPT-4 provides better context understanding than GPT-3.5, reducing irrelevant responses by 40-50%. Temperature of 0.7 balances creativity with consistency. The 150 token limit (roughly 100-120 words) keeps replies concise—critical for Reddit where long comments get skipped. The SKIP mechanism prevents wasting ClickUp tasks on irrelevant posts.

System prompt customization:

Adjust the system prompt to match your brand voice:

Formal professional: "You are a real estate professional providing expert guidance..."
Casual friendly: "You're a helpful neighbor sharing advice about..."
Technical expert: "You are a moving logistics specialist explaining..."

Test different prompts with sample posts to find the voice that generates the best engagement rates.

Step 4: Create ClickUp Review Tasks

Every relevant post with a generated draft becomes a ClickUp task for human review and approval.

Configure ClickUp Node:

{
  "resource": "task",
  "operation": "create",
  "list": "{{$env.CLICKUP_DRAFTS_LIST_ID}}",
  "name": "Reddit Draft: {{ $json.title.slice(0, 100) }}",
  "description": "**Post URL:** {{ $json.link }}

**Post Content:**
{{ $json.content }}

**AI Draft Reply:**
{{ $json.aiDraft }}",
  "status": "New Draft",
  "customFields": {
    "values": [
      {
        "id": "{{$env.CLICKUP_FIELD_POST_URL}}",
        "value": "{{ $json.link }}"
      },
      {
        "id": "{{$env.CLICKUP_FIELD_POST_ID}}", 
        "value": "{{ $json.id }}"
      },
      {
        "id": "{{$env.CLICKUP_FIELD_AI_DRAFT}}",
        "value": "{{ $json.aiDraft }}"
      }
    ]
  }
}

Set up custom fields in ClickUp:

Field Name	Field Type	Purpose
Reddit Post URL	URL	Direct link to original post for context
Reddit Post ID	Text	Thing ID (e.g., t3_abc123) for API posting
AI Draft Reply	Long Text	Editable draft reply text
Posted Comment URL	URL	Link to posted comment (added after posting)

Why this structure:
Storing the Thing ID (Reddit's internal post identifier) in a custom field enables the posting workflow to target the correct post. The AI draft in a custom field allows editing directly in ClickUp without switching tools. Including the full post content in the description provides context for reviewers without requiring them to click through to Reddit.

Task organization tips:

Use ClickUp's "New Draft" status for unreviewed tasks
Create an "Approved for Posting" status to trigger the posting workflow
Add a "Rejected" status for drafts that shouldn't be posted
Set up ClickUp automations to notify reviewers when new drafts arrive

Step 5: Post Approved Replies to Reddit

When a ClickUp task moves to "Approved for Posting," the workflow automatically posts the reply to Reddit.

Set up ClickUp Webhook Trigger:

In ClickUp, go to Space Settings → Webhooks
Create a new webhook pointing to your n8n webhook URL
Select events: "Task Status Updated"
Filter for your Reddit Drafts list

Configure Reddit OAuth:

Reddit's API requires OAuth authentication for posting. Set up credentials in n8n:

{
  "credentialType": "oAuth2Api",
  "clientId": "{{$env.REDDIT_CLIENT_ID}}",
  "clientSecret": "{{$env.REDDIT_CLIENT_SECRET}}",
  "authUrl": "https://www.reddit.com/api/v1/authorize",
  "accessTokenUrl": "https://www.reddit.com/api/v1/access_token",
  "scope": "submit identity read",
  "authQueryParameters": "duration=permanent"
}

Configure HTTP Request Node for posting:

{
  "method": "POST",
  "url": "https://oauth.reddit.com/api/comment",
  "authentication": "oAuth2",
  "sendBody": true,
  "bodyParameters": {
    "parameters": [
      {
        "name": "thing_id",
        "value": "={{ $json.custom_fields.find(f => f.name === 'Reddit Post ID').value }}"
      },
      {
        "name": "text",
        "value": "={{ $json.custom_fields.find(f => f.name === 'AI Draft Reply').value }}"
      },
      {
        "name": "api_type",
        "value": "json"
      }
    ]
  },
  "options": {
    "timeout": 30000
  }
}

Update ClickUp task after posting:

Add another ClickUp node to update the task:

{
  "resource": "task",
  "operation": "update",
  "taskId": "={{ $json.taskId }}",
  "status": "Posted",
  "customFields": {
    "values": [
      {
        "id": "{{$env.CLICKUP_FIELD_COMMENT_URL}}",
        "value": "https://reddit.com{{ $json.json.data.things[0].data.permalink }}"
      }
    ]
  }
}

Why this approach:
Using ClickUp's webhook trigger creates a real-time posting system—approved replies post within seconds. Storing the posted comment URL back in ClickUp creates a complete audit trail. The "Posted" status prevents duplicate posting if the webhook fires multiple times.

Error handling:

Add an Error Trigger node to catch Reddit API failures:

Rate limiting (429 errors): Wait 60 seconds and retry
Authentication errors (401): Alert admin to refresh OAuth token
Post deleted (404): Update ClickUp task to "Post Deleted" status

Workflow Architecture Overview

This workflow consists of 18 nodes organized into 3 main sections:

Monitoring & filtering (Nodes 1-8): Schedule trigger → RSS parsing → keyword filtering → duplicate prevention
Draft generation & task creation (Nodes 9-12): OpenAI draft generation → skip filtering → ClickUp task creation
Approval & posting (Nodes 13-18): Webhook trigger → status check → Reddit posting → ClickUp update

Execution flow:

Trigger: Schedule (every 15 minutes) for monitoring; Webhook for posting
Average run time: 8-12 seconds for monitoring cycle; 2-3 seconds for posting
Key dependencies: Reddit RSS feeds, OpenAI API, ClickUp API, Reddit OAuth

Critical nodes:

RSS Feed Parser: Handles Reddit's RSS format and extracts post metadata
OpenAI Node: Generates contextual drafts with skip logic for irrelevant posts
ClickUp Create Task: Structures review tasks with all necessary context
HTTP Request (Reddit): Posts approved comments using OAuth authentication

The complete n8n workflow JSON template is available at the bottom of this article.

Key Configuration Details

OpenAI Integration

Required fields:

API Key: Your OpenAI API key from platform.openai.com
Model: gpt-4 (or gpt-4-turbo for faster responses)
Temperature: 0.7 (balance between creativity and consistency)
Max Tokens: 150 (approximately 100-120 words)

Common issues:

Using gpt-3.5-turbo → Lower quality drafts with more off-topic responses
Temperature above 0.9 → Inconsistent tone and occasional inappropriate suggestions
Max tokens below 100 → Incomplete responses that cut off mid-sentence

System prompt optimization:

Test your system prompt with 10-15 sample posts before deploying. Look for:

Tone consistency across different post types
Appropriate skip decisions for off-topic posts
Helpful, non-promotional language
Natural conversation flow

Reddit API Configuration

OAuth setup:

Grant type: Password (for script apps)
Scope: submit, identity, read
User agent: YourApp/1.0 (required by Reddit API)

Rate limiting:
Reddit allows 60 requests per minute for OAuth apps. This workflow uses approximately:

1 request per subreddit per monitoring cycle (5 requests/15 min for 5 subreddits)
1 request per approved post for commenting (variable)
Total: ~10-20 requests per hour under normal usage

Variables to customize:

monitoringInterval: Change from 15 minutes to 30 minutes for less active subreddits
keywordList: Add industry-specific terms relevant to your business
maxPostAge: Filter out posts older than 24 hours to focus on fresh content

Testing & Validation

Test the monitoring workflow:

Manually trigger the workflow from n8n
Check the RSS Feed Parser output—you should see 25 recent posts per subreddit
Verify the Filter node removes posts without target keywords
Confirm the OpenAI node generates appropriate drafts
Check ClickUp for new tasks with correct custom field values

Test the posting workflow:

Create a test post in a private subreddit or r/test
Manually create a ClickUp task with the test post's Thing ID
Move the task to "Approved for Posting"
Verify the webhook triggers the posting workflow
Check Reddit for the posted comment
Confirm the ClickUp task updates to "Posted" status

Common troubleshooting:

Issue	Cause	Solution
No tasks created	Keywords too restrictive	Review Filter node conditions; check RSS feed output
"SKIP" for relevant posts	System prompt too conservative	Adjust OpenAI system prompt; lower temperature to 0.6
Reddit posting fails	OAuth token expired	Refresh OAuth credentials in n8n
Duplicate posts	Processed posts list not persisting	Verify Set node stores data in workflow static data
ClickUp webhook not triggering	Webhook URL incorrect	Regenerate webhook URL in n8n; update in ClickUp

Monitoring recommendations:

Set up n8n's error workflow to alert you when:

Reddit API returns 429 (rate limiting)
OpenAI API returns errors (check API quota)
ClickUp task creation fails (check custom field IDs)

Production Deployment Checklist

Area	Requirement	Why It Matters
Error Handling	Retry logic with exponential backoff on Reddit API	Prevents lost comments during temporary API issues
Monitoring	Daily summary email of processed posts	Catch filtering issues before missing opportunities
Documentation	Comment each node with its purpose	Reduces modification time when adjusting workflow
Security	Store all credentials in n8n environment variables	Prevents credential exposure in workflow exports
Backup	Export workflow JSON weekly	Enables quick recovery if workflow is accidentally modified
Rate Limiting	Track Reddit API usage in separate workflow	Avoid account suspension from excessive requests

Production setup:

Move from test subreddits to production targets
Adjust monitoring frequency based on subreddit activity (15-30 minutes)
Set up ClickUp notifications for new drafts
Create a review schedule (check drafts 2-3x daily)
Monitor first week closely to tune keyword filters

Quality control process:

Review first 20-30 AI drafts manually to establish baseline quality
Track approval rate (target: 70-80% of drafts approved without edits)
Adjust system prompt if approval rate drops below 60%
Add negative keywords to filter out unwanted post types

Real-World Use Cases

Use Case 1: SaaS Company Building Community Presence

Industry: B2B SaaS (project management)
Scale: 5 subreddits, 15-20 relevant posts per day
Modifications needed: Add company-specific terminology to keyword filters; adjust system prompt to reference product features naturally
Result: 12 hours/week saved; 3x increase in Reddit-sourced demo requests

Use Case 2: Real Estate Agency Local Market Engagement

Industry: Residential real estate
Scale: 8 city-specific subreddits, 25-30 posts per day
Modifications needed: Add location-based keywords; create separate OpenAI prompts for buyer vs. seller posts
Result: 40% increase in local brand awareness; 15 qualified leads per month

Use Case 3: Moving Company Customer Support

Industry: Moving and logistics
Scale: 12 subreddits, 40-50 posts per day
Modifications needed: Add seasonal keywords (summer moving season); integrate with CRM to track conversions
Result: 85% reduction in response time; 25% increase in quote requests

Use Case 4: Financial Services Educational Content

Industry: Personal finance
Scale: 6 subreddits, 30-35 posts per day
Modifications needed: Add compliance review step in ClickUp; create conservative system prompt to avoid financial advice
Result: 200% increase in blog traffic from Reddit; established thought leadership

Customizations & Extensions

Alternative Integrations

Instead of ClickUp:

Notion: Best for teams already using Notion for project management—requires 3 node changes (Notion API instead of ClickUp)
Airtable: Better if you want custom views and reporting—swap ClickUp nodes for Airtable API calls
Asana: Use when you need advanced task dependencies—similar node structure to ClickUp

Instead of OpenAI:

Anthropic Claude: Better for longer context (up to 100k tokens)—change API endpoint and authentication
Local LLM (Ollama): Best for privacy-sensitive applications—requires self-hosted n8n and Ollama setup
Google Gemini: Lower cost option—similar API structure to OpenAI

Workflow Extensions

Add sentiment analysis:

Add a second OpenAI call to analyze post sentiment before drafting
Route negative sentiment posts to senior reviewers
Adjust draft tone based on original post sentiment
Nodes needed: +3 (OpenAI, Switch, Set)

Implement A/B testing:

Generate 2 draft variations per post
Randomly assign variation to each post
Track engagement metrics (upvotes, replies) in ClickUp
Analyze which draft style performs better
Nodes needed: +5 (Function, Set, HTTP Request for Reddit metrics)

Scale to handle more subreddits:

Replace RSS feeds with Reddit API search (handles 50+ subreddits)
Add batch processing (process 100 posts at a time)
Implement Redis caching for processed post IDs
Performance improvement: 5x faster for 20+ subreddits

Integration possibilities:

Add This	To Get This	Complexity
Google Sheets logging	Track all processed posts and approval rates	Easy (2 nodes)
Slack notifications	Real-time alerts for high-priority posts	Easy (3 nodes)
Sentiment tracking	Analyze community sentiment trends over time	Medium (6 nodes)
CRM integration	Track Reddit leads through sales pipeline	Medium (8 nodes)
Analytics dashboard	Visualize engagement metrics and ROI	Advanced (12+ nodes)

Advanced customization: Multi-account posting

For agencies managing multiple clients:

Add a "Client" field to ClickUp tasks
Store Reddit credentials per client in n8n
Use Switch node to select correct credentials based on client
Post from appropriate Reddit account
Track performance by client in separate reporting workflow

Get Started Today

Ready to automate your Reddit engagement?

Download the template: Scroll to the bottom of this article to copy the complete n8n workflow JSON
Import to n8n: Go to Workflows → Import from File, paste the JSON
Configure your services: Add your API credentials for Reddit, OpenAI, and ClickUp
Set up ClickUp custom fields: Create the four required custom fields in your ClickUp list
Test with one subreddit: Start with a single, low-volume subreddit to verify everything works
Adjust keyword filters: Tune your filters based on the first 20-30 posts processed
Deploy to production: Add all target subreddits and activate the workflow

Initial setup time: 45-60 minutes for first-time setup; 15-20 minutes if you've used these APIs before.

Need help customizing this workflow for your specific needs? Want to add advanced features like sentiment analysis or multi-account management? Schedule an intro call with Atherial at https://atherial.ai/contact—we'll help you build a Reddit engagement system that scales with your business.

Complete n8n Workflow JSON Template

{
  "name": "Reddit AI Drafting & ClickUp Review",
  "nodes": [
    {
      "parameters": {
        "rule": {
          "interval": [
            {
              "field": "minutes",
              "minutesInterval": 15
            }
          ]
        }
      },
      "name": "Schedule Trigger",
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1,
      "position": [250, 300]
    },
    {
      "parameters": {
        "values": {
          "string": [
            {
              "name": "subreddits",
              "value": "=moving,Homeowners,relocation,RealEstate,FirstTimeHomeBuyer"
            }
          ]
        },
        "options": {}
      },
      "name": "Set Subreddits",
      "type": "n8n-nodes-base.set",
      "typeVersion": 1,
      "position": [450, 300]
    },
    {
      "parameters": {
        "url": "=https://www.reddit.com/r/{{ $json.subreddit }}/new.rss",
        "options": {}
      },
      "name": "RSS Feed Parser",
      "type": "n8n-nodes-base.rssFeedRead",
      "typeVersion": 1,
      "position": [850, 300]
    },
    {
      "parameters": {
        "conditions": {
          "string": [
            {
              "value1": "={{ $json.title.toLowerCase() }}",
              "operation": "contains",
              "value2": "moving to"
            }
          ]
        }
      },
      "name": "Filter Keywords",
      "type": "n8n-nodes-base.filter",
      "typeVersion": 1,
      "position": [1050, 300]
    },
    {
      "parameters": {
        "resource": "text",
        "operation": "message",
        "model": "gpt-4",
        "messages": {
          "values": [
            {
              "role": "system",
              "content": "You are a helpful community member providing genuine advice about moving and homeownership. Never promote products or services. If the post is spam, off-topic, or inappropriate, respond with exactly 'SKIP'. Otherwise, provide a brief (2-3 sentences), friendly reply that adds value to the conversation."
            },
            {
              "role": "user",
              "content": "=Post Title: {{ $json.title }}

Post Content: {{ $json.content }}

Draft a helpful reply."
            }
          ]
        },
        "options": {
          "temperature": 0.7,
          "maxTokens": 150
        }
      },
      "name": "OpenAI Draft Generator",
      "type": "n8n-nodes-base.openAi",
      "typeVersion": 1,
      "position": [1250, 300]
    },
    {
      "parameters": {
        "resource": "task",
        "operation": "create",
        "list": "={{$env.CLICKUP_DRAFTS_LIST_ID}}",
        "name": "=Reddit Draft: {{ $json.title.slice(0, 100) }}",
        "description": "=**Post URL:** {{ $json.link }}

**Post Content:**
{{ $json.content }}

**AI Draft Reply:**
{{ $json.aiDraft }}",
        "status": "New Draft",
        "customFields": {
          "customField": [
            {
              "id": "={{$env.CLICKUP_FIELD_POST_URL}}",
              "value": "={{ $json.link }}"
            },
            {
              "id": "={{$env.CLICKUP_FIELD_POST_ID}}",
              "value": "={{ $json.id }}"
            },
            {
              "id": "={{$env.CLICKUP_FIELD_AI_DRAFT}}",
              "value": "={{ $json.aiDraft }}"
            }
          ]
        }
      },
      "name": "Create ClickUp Task",
      "type": "n8n-nodes-base.clickUp",
      "typeVersion": 1,
      "position": [1650, 300]
    },
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "reddit-approval",
        "responseMode": "responseNode",
        "options": {}
      },
      "name": "ClickUp Webhook",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1,
      "position": [250, 500]
    },
    {
      "parameters": {
        "method": "POST",
        "url": "https://oauth.reddit.com/api/comment",
        "authentication": "oAuth2",
        "sendBody": true,
        "bodyParameters": {
          "parameters": [
            {
              "name": "thing_id",
              "value": "={{ $json.custom_fields.find(f => f.name === 'Reddit Post ID').value }}"
            },
            {
              "name": "text",
              "value": "={{ $json.custom_fields.find(f => f.name === 'AI Draft Reply').value }}"
            },
            {
              "name": "api_type",
              "value": "json"
            }
          ]
        },
        "options": {
          "timeout": 30000
        }
      },
      "name": "Post to Reddit",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 3,
      "position": [650, 500]
    },
    {
      "parameters": {
        "resource": "task",
        "operation": "update",
        "taskId": "={{ $json.taskId }}",
        "status": "Posted",
        "customFields": {
          "customField": [
            {
              "id": "={{$env.CLICKUP_FIELD_COMMENT_URL}}",
              "value": "=https://reddit.com{{ $json.json.data.things[0].data.permalink }}"
            }
          ]
        }
      },
      "name": "Update ClickUp Task",
      "type": "n8n-nodes-base.clickUp",
      "typeVersion": 1,
      "position": [850, 500]
    }
  ],
  "connections": {
    "Schedule Trigger": {
      "main": [
        [
          {
            "node": "Set Subreddits",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Set Subreddits": {
      "main": [
        [
          {
            "node": "RSS Feed Parser",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "RSS Feed Parser": {
      "main": [
        [
          {
            "node": "Filter Keywords",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Filter Keywords": {
      "main": [
        [
          {
            "node": "OpenAI Draft Generator",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "OpenAI Draft Generator": {
      "main": [
        [
          {
            "node": "Create ClickUp Task",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "ClickUp Webhook": {
      "main": [
        [
          {
            "node": "Post to Reddit",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Post to Reddit": {
      "main": [
        [
          {
            "node": "Update ClickUp Task",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "settings": {
    "executionOrder": "v1"
  }
}

Complete N8N Workflow Template

Copy the JSON below and import it into your N8N instance via Workflows → Import from File

{
  "name": "Reddit to ClickUp AI Draft Review",
  "nodes": [
    {
      "id": "a1b2c3d4-e5f6-g7h8-i9j0-k1l2m3n4o5p6",
      "name": "Schedule Trigger",
      "type": "n8n-nodes-base.scheduleTrigger",
      "position": [
        250,
        300
      ],
      "parameters": {
        "rule": {
          "interval": [
            {
              "field": "minutes",
              "minutesInterval": 15
            }
          ]
        }
      },
      "typeVersion": 1.2
    },
    {
      "id": "b2c3d4e5-f6g7-h8i9-j0k1-l2m3n4o5p6q7",
      "name": "Get Reddit Posts",
      "type": "n8n-nodes-base.reddit",
      "position": [
        470,
        300
      ],
      "parameters": {
        "limit": 20,
        "resource": "post",
        "operation": "getAll",
        "subreddit": "automation"
      },
      "typeVersion": 1
    },
    {
      "id": "c3d4e5f6-g7h8-i9j0-k1l2-m3n4o5p6q7r8",
      "name": "Filter Relevant Posts",
      "type": "n8n-nodes-base.code",
      "position": [
        690,
        300
      ],
      "parameters": {
        "mode": "runOnceForAllItems",
        "jsCode": "// Filter posts that haven't been processed\nconst relevantKeywords = ['automation', 'workflow', 'integration', 'api', 'help'];\nconst minUpvotes = 5;\n\nconst filteredPosts = [];\n\nfor (const item of $input.all()) {\n  const post = item.json;\n  const title = (post.title || '').toLowerCase();\n  const body = (post.selftext || '').toLowerCase();\n  const upvotes = post.ups || 0;\n  \n  const hasKeyword = relevantKeywords.some(keyword => \n    title.includes(keyword) || body.includes(keyword)\n  );\n  \n  if (hasKeyword && upvotes >= minUpvotes && !post.stickied) {\n    filteredPosts.push({\n      json: {\n        postId: post.id,\n        postName: post.name,\n        subreddit: post.subreddit,\n        title: post.title,\n        body: post.selftext || '',\n        author: post.author,\n        url: `https://reddit.com${post.permalink}`,\n        upvotes: post.ups,\n        comments: post.num_comments,\n        created: post.created_utc\n      }\n    });\n  }\n}\n\nreturn filteredPosts;"
      },
      "typeVersion": 2
    },
    {
      "id": "d4e5f6g7-h8i9-j0k1-l2m3-n4o5p6q7r8s9",
      "name": "Has Posts?",
      "type": "n8n-nodes-base.if",
      "position": [
        910,
        300
      ],
      "parameters": {
        "conditions": {
          "options": {
            "leftValue": "",
            "caseSensitive": false,
            "typeValidation": "strict"
          },
          "combinator": "and",
          "conditions": [
            {
              "operator": {
                "type": "string",
                "operation": "notEmpty"
              },
              "leftValue": "={{ $json.postId }}",
              "rightValue": ""
            }
          ]
        }
      },
      "typeVersion": 2.2
    },
    {
      "id": "e5f6g7h8-i9j0-k1l2-m3n4-o5p6q7r8s9t0",
      "name": "Generate AI Reply",
      "type": "n8n-nodes-base.openAi",
      "position": [
        1130,
        200
      ],
      "parameters": {
        "model": "gpt-4o-mini",
        "prompt": "=You are a helpful community member on Reddit r/{{ $json.subreddit }}.\n\nPost Title: {{ $json.title }}\nPost Content: {{ $json.body }}\nAuthor: u/{{ $json.author }}\n\nGenerate a thoughtful, helpful reply. Be genuine, conversational, and provide actionable advice. 2-4 paragraphs, using markdown formatting.\n\nReply:",
        "options": {
          "maxTokens": 500,
          "temperature": 0.7
        },
        "resource": "text",
        "operation": "complete"
      },
      "typeVersion": 1.1
    },
    {
      "id": "f6g7h8i9-j0k1-l2m3-n4o5-p6q7r8s9t0u1",
      "name": "Prepare Task Data",
      "type": "n8n-nodes-base.code",
      "position": [
        1350,
        200
      ],
      "parameters": {
        "mode": "runOnceForEachItem",
        "jsCode": "const postData = $('Filter Relevant Posts').item.json;\nconst aiOutput = $input.item.json;\nconst replyText = aiOutput.choices?.[0]?.text || aiOutput.text || '';\n\nreturn {\n  json: {\n    postId: postData.postId,\n    postName: postData.postName,\n    subreddit: postData.subreddit,\n    postTitle: postData.title,\n    postBody: postData.body,\n    postUrl: postData.url,\n    author: postData.author,\n    aiReply: replyText.trim(),\n    upvotes: postData.upvotes\n  }\n};"
      },
      "typeVersion": 2
    },
    {
      "id": "g7h8i9j0-k1l2-m3n4-o5p6-q7r8s9t0u1v2",
      "name": "Create ClickUp Task",
      "type": "n8n-nodes-base.clickUp",
      "position": [
        1570,
        200
      ],
      "parameters": {
        "list": "={{ $env.CLICKUP_LIST_ID }}",
        "name": "=Review: {{ $json.postTitle.substring(0, 50) }}...",
        "team": "={{ $env.CLICKUP_TEAM_ID }}",
        "space": "={{ $env.CLICKUP_SPACE_ID }}",
        "resource": "task",
        "operation": "create",
        "folderless": true,
        "additionalFields": {
          "status": "to review",
          "priority": 3,
          "description": "=**Post**: {{ $json.postUrl }}\n**Subreddit**: r/{{ $json.subreddit }}\n**Author**: u/{{ $json.author }}\n**Upvotes**: {{ $json.upvotes }}\n\n**Title**: {{ $json.postTitle }}\n\n**Content**:\n{{ $json.postBody }}\n\n---\n\n**AI Generated Reply**:\n{{ $json.aiReply }}\n\n---\nReview and approve to post to Reddit.",
          "customFieldsJson": "=[\n  {\"id\": \"{{ $env.CLICKUP_FIELD_POST_ID }}\", \"value\": \"{{ $json.postName }}\"},\n  {\"id\": \"{{ $env.CLICKUP_FIELD_REPLY }}\", \"value\": \"{{ $json.aiReply }}\"}\n]"
        }
      },
      "typeVersion": 1
    },
    {
      "id": "h8i9j0k1-l2m3-n4o5-p6q7-r8s9t0u1v2w3",
      "name": "ClickUp Task Updated",
      "type": "n8n-nodes-base.clickUpTrigger",
      "position": [
        250,
        600
      ],
      "webhookId": "webhook-clickup-001",
      "parameters": {
        "team": "={{ $env.CLICKUP_TEAM_ID }}",
        "events": [
          "taskUpdated"
        ],
        "filters": {
          "listId": "={{ $env.CLICKUP_LIST_ID }}"
        }
      },
      "typeVersion": 1
    },
    {
      "id": "i9j0k1l2-m3n4-o5p6-q7r8-s9t0u1v2w3x4",
      "name": "Is Approved?",
      "type": "n8n-nodes-base.if",
      "position": [
        470,
        600
      ],
      "parameters": {
        "conditions": {
          "options": {
            "leftValue": "",
            "caseSensitive": false,
            "typeValidation": "strict"
          },
          "combinator": "and",
          "conditions": [
            {
              "operator": {
                "type": "string",
                "operation": "equals"
              },
              "leftValue": "={{ $json.status.status.toLowerCase() }}",
              "rightValue": "approved"
            }
          ]
        }
      },
      "typeVersion": 2.2
    },
    {
      "id": "j0k1l2m3-n4o5-p6q7-r8s9-t0u1v2w3x4y5",
      "name": "Extract Task Data",
      "type": "n8n-nodes-base.code",
      "position": [
        690,
        500
      ],
      "parameters": {
        "mode": "runOnceForEachItem",
        "jsCode": "const task = $input.item.json;\nconst customFields = task.custom_fields || [];\n\nconst postIdField = customFields.find(f => f.name && f.name.toLowerCase().includes('post'));\nconst replyField = customFields.find(f => f.name && f.name.toLowerCase().includes('reply'));\n\nconst postName = postIdField?.value || '';\nconst replyText = replyField?.value || task.description || '';\n\nconst postId = postName.replace('t3_', '');\n\nreturn {\n  json: {\n    taskId: task.id,\n    postId: postId,\n    postName: postName,\n    replyText: replyText\n  }\n};"
      },
      "typeVersion": 2
    },
    {
      "id": "k1l2m3n4-o5p6-q7r8-s9t0-u1v2w3x4y5z6",
      "name": "Post to Reddit",
      "type": "n8n-nodes-base.reddit",
      "position": [
        910,
        500
      ],
      "parameters": {
        "postId": "={{ $json.postId }}",
        "resource": "postComment",
        "operation": "create",
        "commentText": "={{ $json.replyText }}"
      },
      "typeVersion": 1
    },
    {
      "id": "l2m3n4o5-p6q7-r8s9-t0u1-v2w3x4y5z6a7",
      "name": "Update Task Status",
      "type": "n8n-nodes-base.clickUp",
      "position": [
        1130,
        500
      ],
      "parameters": {
        "id": "={{ $('ClickUp Task Updated').item.json.id }}",
        "resource": "task",
        "operation": "update",
        "updateFields": {
          "status": "posted",
          "content": "=✅ Posted to Reddit at {{ new Date().toISOString() }}\n\nComment URL: https://reddit.com{{ $('Post to Reddit').item.json.permalink || '' }}"
        }
      },
      "typeVersion": 1
    }
  ],
  "settings": {
    "executionOrder": "v1"
  },
  "connections": {
    "Has Posts?": {
      "main": [
        [
          {
            "node": "Generate AI Reply",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Is Approved?": {
      "main": [
        [
          {
            "node": "Extract Task Data",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Post to Reddit": {
      "main": [
        [
          {
            "node": "Update Task Status",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Get Reddit Posts": {
      "main": [
        [
          {
            "node": "Filter Relevant Posts",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Schedule Trigger": {
      "main": [
        [
          {
            "node": "Get Reddit Posts",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Extract Task Data": {
      "main": [
        [
          {
            "node": "Post to Reddit",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Generate AI Reply": {
      "main": [
        [
          {
            "node": "Prepare Task Data",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Prepare Task Data": {
      "main": [
        [
          {
            "node": "Create ClickUp Task",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "ClickUp Task Updated": {
      "main": [
        [
          {
            "node": "Is Approved?",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Filter Relevant Posts": {
      "main": [
        [
          {
            "node": "Has Posts?",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}