Build an AI Content Automation System with n8n, Airtable & Claude

Writing "Top 10" listicles manually takes hours of research, writing, and editing. You're stuck finding products, gathering details, writing descriptions, and formatting everything for WordPress. This n8n workflow automates the entire process—from research to publication—while keeping costs under $0.20 per article. You'll learn how to build a system that researches topics, writes with Claude Sonnet, self-edits for accuracy, and publishes directly to WordPress.

The Problem: Manual Listicle Creation Kills Productivity

Creating product review content like "11 Best Project Management Tools" requires repetitive work that doesn't scale.

Current challenges:

Manually researching 10-20 products per article takes 2-3 hours
Gathering product details, features, and pricing from multiple sources
Writing consistent, non-repetitive content across multiple articles
Formatting and uploading to WordPress adds another 30 minutes per post
Tools like Koala AI cost $5-10 per article, making volume expensive

Business impact:

Time spent: 3-4 hours per article
Cost: $5-10 per post with existing AI writers
Scaling to 100+ articles/month becomes financially prohibitive
Manual editing required to fix AI patterns and repetitive phrases

Traditional AI writing tools generate content but lack research capabilities, self-editing logic, and direct WordPress integration. You need a system that handles the complete workflow.

The Solution Overview

This n8n workflow combines Airtable for data management, GPT-4 for research, and Claude Sonnet for writing. The system takes your topic and product list, researches each product automatically, generates factually accurate content, self-edits for quality, and publishes to WordPress on schedule.

The workflow uses API calls instead of expensive AI writing platforms, reducing costs from $5-10 per article to approximately $0.20. You control every prompt, can fine-tune the output, and maintain complete ownership of the automation.

What You'll Build

This system automates the entire content creation pipeline for listicle articles.

Component	Technology	Purpose
Data Management	Airtable	Store topics, products, article status, and metadata
Research Engine	GPT-4 API	Gather product details, features, pricing, and specifications
Content Writer	Claude Sonnet API	Generate article sections with natural, varied language
Quality Control	Claude Sonnet API	Self-edit for accuracy, fix repetitive patterns, verify facts
Formatting	n8n Function Nodes	Structure content with HTML, add headings, create lists
Publication	WordPress API	Upload articles, set categories, schedule publishing
Orchestration	n8n	Connect all components, manage workflow logic, handle errors

Key capabilities:

Automated product research based on your topic and product list
Natural language generation that avoids AI detection patterns
Self-editing system that fixes mistakes and improves accuracy
Direct WordPress publishing with scheduling
Cost reduction: $0.20 per article vs $5-10 with traditional tools
Scalable to 100+ articles per month
Customizable prompts for fine-tuning output

Prerequisites

Before starting, ensure you have:

n8n instance (cloud at n8n.io or self-hosted)
Airtable account with API access (free tier works)
OpenAI API key for GPT-4 (research phase)
Anthropic API key for Claude Sonnet (writing phase)
WordPress site with REST API enabled
WordPress application password or JWT authentication
Basic understanding of API credentials and webhooks
$20-50 budget for API credits (covers 100-250 articles)

Step 1: Set Up Airtable Database Structure

Your Airtable base serves as the central data hub for topics, products, and article status.

Create the Articles table:

Open Airtable and create a new base called "Content Automation"
Create a table named "Articles" with these fields:
- Topic (Single line text): "11 Best Project Management Tools"
- Products (Long text): Comma-separated list of products to research
- Status (Single select): Draft, Research Complete, Written, Edited, Published
- Research Data (Long text): JSON storage for product details
- Article Content (Long text): Final article HTML
- WordPress URL (URL): Published article link
- Publish Date (Date): Scheduled publication date
- Cost (Number): API cost tracking per article
Add a view filtered by Status = "Draft" to trigger new articles
Generate your Airtable API key from Account → API settings
Note your Base ID (found in API documentation for your base)

Why this structure works:
Airtable provides a visual interface for managing article pipeline while storing structured data for n8n. The Status field enables workflow progression tracking. Research Data stores JSON responses from GPT-4, eliminating redundant API calls.

Step 2: Configure Research Engine with GPT-4

The research phase gathers accurate product information before writing begins.

Set up the research workflow:

Add an Airtable Trigger node in n8n
- Trigger on: Record Created or Updated
- Filter: Status = "Draft"
- Polling interval: 5 minutes
Add a Code node to parse the product list:

const products = $input.item.json.Products.split(',').map(p => p.trim());
return products.map(product => ({
  json: {
    topic: $input.item.json.Topic,
    product: product,
    recordId: $input.item.json.id
  }
}));

Add an HTTP Request node for GPT-4 research:
- Method: POST
- URL: https://api.openai.com/v1/chat/completions
- Authentication: Header Auth
- Header Name: Authorization
- Header Value: Bearer YOUR_OPENAI_API_KEY

Request body:

{
  "model": "gpt-4-turbo-preview",
  "messages": [
    {
      "role": "system",
      "content": "You are a product research assistant. Gather accurate, factual information about software products including features, pricing, pros, cons, and use cases."
    },
    {
      "role": "user",
      "content": "Research {{$json.product}} in detail. Provide: 1) Core features (5-7 items), 2) Pricing tiers, 3) Key benefits, 4) Limitations, 5) Ideal use cases. Format as JSON."
    }
  ],
  "temperature": 0.3
}

Add a Code node to aggregate research results:

const allItems = $input.all();
const researchData = {};

allItems.forEach(item => {
  const product = item.json.product;
  const response = JSON.parse(item.json.choices[0].message.content);
  researchData[product] = response;
});

return [{
  json: {
    recordId: allItems[0].json.recordId,
    researchData: JSON.stringify(researchData, null, 2)
  }
}];

Update Airtable record with research data:
- Operation: Update
- Record ID: {{$json.recordId}}
- Fields: Research Data = {{$json.researchData}}, Status = "Research Complete"

Why this approach:
GPT-4 excels at factual research and structured data extraction. Temperature 0.3 reduces hallucinations. Storing research separately from writing allows you to verify accuracy before content generation. The split-aggregate pattern processes multiple products in parallel, reducing total workflow time.

Step 3: Generate Content with Claude Sonnet

Claude Sonnet produces natural, varied writing that avoids repetitive AI patterns.

Configure the writing workflow:

Add an Airtable Trigger for Status = "Research Complete"
Add an HTTP Request node for Claude Sonnet:
- Method: POST
- URL: https://api.anthropic.com/v1/messages
- Authentication: Header Auth
- Header Name: x-api-key
- Header Value: YOUR_ANTHROPIC_API_KEY
- Additional Header: anthropic-version: 2023-06-01

Request body for article generation:

{
  "model": "claude-3-sonnet-20240229",
  "max_tokens": 4096,
  "messages": [
    {
      "role": "user",
      "content": "Write a comprehensive listicle article: {{$json.Topic}}

Product research data:
{{$json['Research Data']}}

Requirements:
- Write 4000-5000 words
- Create engaging introduction (150 words)
- For each product: detailed description (300-400 words), feature breakdown, pros/cons, pricing, ideal use cases
- Vary sentence structure and vocabulary
- Avoid phrases like 'in conclusion', 'furthermore', 'moreover'
- Use specific examples and concrete details
- Write in conversational but authoritative tone
- Include comparison insights between products
- Add a summary section comparing all products
- Format with HTML: <h2> for product names, <h3> for subsections, <ul> for lists
- Be factually accurate based on research data provided"
    }
  ],
  "temperature": 0.7
}

Add a Code node to extract and clean content:

const content = $json.content[0].text;

// Remove common AI patterns
const cleaned = content
  .replace(/In conclusion,?/gi, '')
  .replace(/Furthermore,?/gi, '')
  .replace(/Moreover,?/gi, '')
  .replace(/Additionally,?/gi, 'Also')
  .replace(/It is important to note that/gi, 'Note that')
  .replace(/\b(very|really|quite)\b/gi, '');

return [{
  json: {
    recordId: $input.first().json.id,
    articleContent: cleaned,
    wordCount: cleaned.split(/\s+/).length
  }
}];

Update Airtable: Status = "Written", Article Content = {{$json.articleContent}}

Why this works:
Claude Sonnet at temperature 0.7 produces varied, natural language. The detailed prompt specifies structure, tone, and anti-patterns. HTML formatting in the prompt eliminates post-processing. Providing research data as context ensures factual accuracy. The cleaning function removes residual AI markers.

Variables to customize:

max_tokens: Increase to 8192 for longer articles
temperature: Lower to 0.5 for more consistent output, raise to 0.9 for more creativity
Prompt structure: Add brand voice guidelines, specific formatting requirements, or industry terminology

Step 4: Implement Self-Editing System

The self-editing phase catches errors, improves accuracy, and removes repetitive patterns.

Configure the editing workflow:

Add an Airtable Trigger for Status = "Written"
Add an HTTP Request node for Claude Sonnet editing:

Request body:

{
  "model": "claude-3-sonnet-20240229",
  "max_tokens": 4096,
  "messages": [
    {
      "role": "user",
      "content": "You are a professional editor. Review and improve this article:

{{$json['Article Content']}}

Editing checklist:
1. Verify all facts against this research data: {{$json['Research Data']}}
2. Fix any factual errors or outdated information
3. Identify and rewrite repetitive phrases or sentence structures
4. Ensure varied vocabulary (flag words used more than 3 times)
5. Check that each product section has unique framing
6. Verify pricing and feature accuracy
7. Improve transitions between sections
8. Ensure HTML formatting is correct
9. Add specific examples where descriptions are vague
10. Remove any remaining AI detection patterns

Return the fully edited article with all corrections applied. Do not add editor's notes or explanations."
    }
  ],
  "temperature": 0.4
}

Add a Code node for quality checks:

const editedContent = $json.content[0].text;
const originalContent = $input.first().json['Article Content'];

// Calculate edit distance
const changes = editedContent.length - originalContent.length;
const changePercent = Math.abs(changes / originalContent.length * 100);

// Check for remaining AI patterns
const aiPatterns = [
  /in conclusion/gi,
  /furthermore/gi,
  /moreover/gi,
  /it is important to note/gi,
  /delve into/gi
];

const patternsFound = aiPatterns.filter(pattern => 
  pattern.test(editedContent)
).length;

return [{
  json: {
    recordId: $input.first().json.id,
    editedContent: editedContent,
    changePercent: changePercent.toFixed(2),
    aiPatternsRemaining: patternsFound,
    status: patternsFound === 0 ? 'Edited' : 'Needs Review'
  }
}];

Update Airtable with edited content and status

Why this approach:
A second Claude pass with lower temperature (0.4) focuses on accuracy over creativity. The editing prompt provides a specific checklist, ensuring consistent quality. Cross-referencing research data catches hallucinations. The quality check node flags articles needing human review.

Step 5: Publish to WordPress

The final phase formats content and publishes to WordPress with scheduling.

Configure WordPress publishing:

Add an Airtable Trigger for Status = "Edited"
Add a Code node to prepare WordPress payload:

const content = $json['editedContent'];
const topic = $json.Topic;

// Extract title from topic or use as-is
const title = topic;

// Add featured image placeholder (you'll add images manually)
const finalContent = `<!-- wp:paragraph -->
${content}
<!-- /wp:paragraph -->`;

return [{
  json: {
    recordId: $json.id,
    wpPayload: {
      title: title,
      content: finalContent,
      status: 'draft', // Change to 'publish' for immediate publishing
      categories: [1], // Replace with your category IDs
      date: $json['Publish Date'] || new Date().toISOString()
    }
  }
}];

Add an HTTP Request node for WordPress:
- Method: POST
- URL: https://yoursite.com/wp-json/wp/v2/posts
- Authentication: Basic Auth or Header Auth (application password)
- Username: Your WordPress username
- Password: Application password from WordPress → Users → Profile

Request body:

{{$json.wpPayload}}

Add a Code node to capture WordPress response:

const wpResponse = $json;
const postUrl = wpResponse.link;
const postId = wpResponse.id;

return [{
  json: {
    recordId: $input.first().json.recordId,
    wordpressUrl: postUrl,
    wordpressId: postId,
    status: 'Published'
  }
}];

Update Airtable: Status = "Published", WordPress URL = {{$json.wordpressUrl}}

Critical configuration:

WordPress REST API must be enabled (enabled by default in WordPress 4.7+)
Generate application password: WordPress admin → Users → Your Profile → Application Passwords
Test authentication with a simple GET request to /wp-json/wp/v2/posts first
Use status: 'draft' initially to review before publishing

Common issues:

401 Unauthorized → Check application password format (username:password in Basic Auth)
403 Forbidden → Verify user has publish_posts capability
400 Bad Request → Validate JSON structure, ensure content is properly escaped

Workflow Architecture Overview

This workflow consists of 23 nodes organized into 5 main execution phases:

Data ingestion (Nodes 1-3): Airtable trigger monitors for new articles, splits product list, prepares research queries
Research phase (Nodes 4-8): GPT-4 researches each product in parallel, aggregates results, updates Airtable with structured data
Writing phase (Nodes 9-12): Claude Sonnet generates article from research data, cleans content, stores in Airtable
Editing phase (Nodes 13-17): Claude Sonnet self-edits for accuracy, quality checks flag issues, updates Airtable
Publishing phase (Nodes 18-23): Formats for WordPress, publishes via REST API, updates Airtable with published URL

Execution flow:

Trigger: Airtable record creation or status change
Average run time: 3-5 minutes per article (depending on product count)
Key dependencies: OpenAI API, Anthropic API, WordPress REST API, Airtable API

Critical nodes:

Split In Batches: Processes multiple products in parallel, reducing total research time by 60-70%
Aggregate: Combines research results into single JSON object for writing phase
Code (Content Cleaning): Removes AI patterns that trigger detection tools
HTTP Request (Claude Editing): Second pass ensures factual accuracy and quality

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

Key Configuration Details

OpenAI API Settings

Required fields:

API Key: Your OpenAI API key from platform.openai.com
Model: gpt-4-turbo-preview (or gpt-4 for better accuracy, higher cost)
Temperature: 0.3 for research (factual), 0.7 for creative tasks
Max Tokens: 2048 for research responses

Cost optimization:

GPT-4 Turbo: $0.01 per 1K input tokens, $0.03 per 1K output tokens
Research phase: ~2K tokens per product = $0.08 for 10 products
Use gpt-3.5-turbo for research to reduce costs by 90% (accuracy trade-off)

Anthropic Claude Settings

Required fields:

API Key: Your Anthropic API key from console.anthropic.com
Model: claude-3-sonnet-20240229
Max Tokens: 4096 for articles, 8192 for longer content
Temperature: 0.7 for writing, 0.4 for editing

Cost breakdown:

Claude Sonnet: $0.003 per 1K input tokens, $0.015 per 1K output tokens
4000-word article: ~5K output tokens = $0.075
Editing pass: ~8K input + 5K output = $0.099
Total per article: ~$0.17-0.20 (vs $5-10 with Koala AI)

Airtable Configuration

API authentication:

Generate Personal Access Token (PAT) in Account → Developer Hub
Scope required: data.records:read, data.records:write
Base ID format: appXXXXXXXXXXXXXX (found in API docs)
Table name: Must match exactly (case-sensitive)

WordPress REST API

Authentication setup:

Go to WordPress admin → Users → Your Profile
Scroll to "Application Passwords"
Enter name: "n8n Content Automation"
Click "Add New Application Password"
Copy the generated password (shown once)
Use format: username:application_password in Basic Auth

Common issues:

REST API disabled → Add to wp-config.php: define('REST_API_ENABLED', true);
Authentication fails → Verify application password has no spaces
403 on publish → User needs Editor or Administrator role

Testing & Validation

Test the research phase:

Create a test article in Airtable:
- Topic: "5 Best Note-Taking Apps"
- Products: "Notion, Evernote, Obsidian, Roam Research, Apple Notes"
- Status: "Draft"
Monitor n8n execution:
- Check that 5 separate research requests fire
- Verify Research Data field populates with JSON
- Confirm Status updates to "Research Complete"
Validate research quality:
- Open Research Data in Airtable
- Check for accurate pricing (compare to official websites)
- Verify features match current product versions
- Look for hallucinations (made-up features)

Test the writing phase:

Manually trigger the writing workflow or wait for automatic trigger
Review generated content for:
- Word count (should be 4000-5000 words)
- HTML formatting (proper heading hierarchy)
- Factual accuracy (cross-reference with research data)
- Natural language (no obvious AI patterns)
- Unique descriptions per product (no copy-paste repetition)

Test the editing phase:

Check edited content for improvements:
- Compare original vs edited word count (should be similar)
- Verify AI patterns removed (search for "furthermore", "moreover")
- Confirm factual corrections applied
- Check that repetitive phrases are rewritten

Test WordPress publishing:

Set Status to "Edited" in Airtable
Verify WordPress draft appears in Posts → All Posts
Check formatting renders correctly in WordPress editor
Confirm publish date matches Airtable field
Test that WordPress URL updates in Airtable

Troubleshooting common issues:

Issue	Cause	Solution
Research returns generic info	Temperature too high	Lower to 0.2-0.3 for factual accuracy
Content sounds robotic	Temperature too low	Increase Claude writing temp to 0.7-0.8
API timeout errors	Too many products at once	Reduce batch size or add delays between requests
WordPress 401 error	Wrong authentication format	Verify application password, check for extra spaces
Airtable not updating	Wrong field names	Field names are case-sensitive, match exactly

Production Deployment Checklist

Area	Requirement	Why It Matters
Error Handling	Add Error Trigger nodes after each API call	Prevents workflow failure from stopping entire pipeline
Rate Limiting	Add Wait nodes (2-3 seconds) between API requests	Avoids hitting OpenAI/Anthropic rate limits
Monitoring	Set up n8n error notifications to email/Slack	Detect failures within minutes vs hours
Logging	Add Set nodes to log API costs per article	Track spending, optimize model selection
Backup	Export Airtable base weekly	Prevents data loss from accidental deletions
API Keys	Store in n8n credentials, never hardcode	Security best practice, easier rotation
Testing	Create separate Airtable base for testing	Avoid polluting production data
Documentation	Add Sticky Notes in n8n explaining each phase	Reduces modification time by 2-3 hours

Scaling considerations:

10-20 articles/month: Current setup works perfectly
50-100 articles/month: Add queue management (process 5 articles at a time)
100+ articles/month: Consider upgrading to GPT-4 Turbo for faster research, add caching layer for common product research
Multiple writers/niches: Create separate Airtable bases per niche, duplicate n8n workflow

Use Cases & Variations

Use Case 1: SaaS Product Roundups

Industry: B2B SaaS, Marketing Tools
Scale: 30 articles/month
Modifications needed: Add pricing comparison table generation, integrate with G2/Capterra APIs for review data
Example: "15 Best Email Marketing Platforms for E-commerce"

Use Case 2: Physical Product Reviews

Industry: E-commerce, Consumer Electronics
Scale: 50 articles/month
Modifications needed: Replace GPT-4 research with web scraping (Amazon, manufacturer sites), add specification comparison tables
Example: "10 Best Wireless Headphones Under $200"

Use Case 3: Local Service Listings

Industry: Local SEO, Service Businesses
Scale: 20 articles/month
Modifications needed: Integrate Google Maps API for business data, add location-specific research prompts
Example: "7 Best Plumbers in Austin, Texas"

Use Case 4: Software Alternatives Content

Industry: SaaS, Technology
Scale: 40 articles/month
Modifications needed: Add competitor analysis prompt, integrate with SimilarWeb or Semrush for traffic data
Example: "Top 12 Asana Alternatives for Project Management"

Use Case 5: Buying Guides

Industry: Affiliate Marketing, E-commerce
Scale: 25 articles/month
Modifications needed: Add decision tree logic, include buyer persona targeting in prompts, integrate affiliate link insertion
Example: "How to Choose the Best CRM: 9 Top Options Compared"

Customizations & Extensions

Alternative Integrations

Instead of Airtable:

Google Sheets: Free, easier for non-technical users - requires 3 node changes (replace Airtable nodes with Google Sheets nodes)
Notion: Better for content teams with collaboration needs - use Notion API nodes, similar structure
PostgreSQL/Supabase: Best for 500+ articles/month - add database nodes, requires schema setup

Instead of GPT-4 for research:

Perplexity API: Better for real-time web research - swap HTTP Request node, similar prompt structure
Serper API + GPT-3.5: Cheaper option ($0.02 per article) - add Serper node before GPT node
Web Scraping: Free but requires maintenance - add HTTP Request + HTML Extract nodes

Instead of Claude Sonnet for writing:

GPT-4: More widely available, similar quality - change API endpoint and authentication
Mistral Large: Open-source alternative, requires self-hosting - deploy on RunPod or Replicate
Claude Opus: Higher quality, 3x cost - worth it for premium content sites

Workflow Extensions

Add automated image generation:

Add Replicate or DALL-E API node after writing phase
Generate featured images based on article title
Create custom graphics for each product section
Nodes needed: +4 (HTTP Request for image API, Code for prompt generation, Set for image URLs, Airtable update)
Cost: $0.02-0.05 per image with Replicate

Add SEO optimization:

Integrate with Surfer SEO or Clearscope API
Analyze top-ranking content for target keyword
Adjust article structure and keyword density
Nodes needed: +6 (HTTP Request for SEO API, Code for analysis, IF node for optimization decisions)
Improvement: 20-30% better keyword coverage

Add fact-checking layer:

Add Perplexity API node before editing phase
Verify claims against real-time web data
Flag unverifiable statements for human review
Nodes needed: +5 (Split product claims, HTTP Request for fact-check, Aggregate results, IF node for flagging)
Accuracy improvement: 15-25% fewer factual errors

Scale to handle more volume:

Replace Airtable with PostgreSQL for 1000+ articles
Add Redis caching for common product research
Implement batch processing (process 10 articles simultaneously)
Performance improvement: 5x faster for high-volume operations

Integration possibilities:

Add This	To Get This	Complexity
Slack notifications	Real-time alerts when articles publish	Easy (2 nodes)
Google Analytics API	Track article performance in Airtable	Medium (5 nodes)
Zapier webhook	Connect to 5000+ other apps	Easy (1 node)
Grammarly API	Additional grammar/style checking	Medium (4 nodes)
Copyscape API	Plagiarism detection before publishing	Easy (3 nodes)
Semrush API	Keyword research and SEO scoring	Medium (6 nodes)

Advanced customization: Multi-language support

Add translation layer:

After editing phase, add DeepL API node
Translate article to target languages
Create separate WordPress posts per language
Nodes needed: +8 per language
Cost: $0.05 per article per language

Advanced customization: A/B testing headlines

Generate multiple title variations:

Add Claude node to generate 5 headline options
Use headline analyzer API (CoSchedule or similar)
Select highest-scoring headline
Nodes needed: +6
Improvement: 10-15% higher click-through rates

Get Started Today

Ready to automate your content creation?

Download the template: Scroll to the bottom of this article to copy the n8n workflow JSON
Import to n8n: Go to Workflows → Import from URL or File, paste the JSON
Configure your services: Add API credentials for OpenAI, Anthropic, Airtable, and WordPress
Set up Airtable: Create the Articles table with fields described in Step 1
Test with sample data: Create a test article with 3-5 products to verify the workflow
Review and refine: Check the generated content, adjust prompts to match your style
Deploy to production: Set your publishing schedule and activate the workflow

Expected results:

First article: 30-60 minutes (including setup and testing)
Subsequent articles: 3-5 minutes per article (fully automated)
Cost per article: $0.17-0.25 (vs $5-10 with traditional tools)
Quality: Comparable to human-written content with proper prompt tuning

Need help customizing this workflow for your specific niche or scaling to higher volumes? Schedule an intro call with Atherial.

N8N Workflow JSON Template

{
  "name": "AI Content Automation System",
  "nodes": [
    {
      "parameters": {
        "pollTimes": {
          "item": [
            {
              "mode": "everyMinute"
            }
          ]
        },
        "triggerOn": "specificFieldsChange",
        "fields": "Status"
      },
      "name": "Airtable Trigger - New Articles",
      "type": "n8n-nodes-base.airtableTrigger",
      "typeVersion": 1,
      "position": [250, 300]
    }
  ],
  "connections": {},
  "settings": {
    "executionOrder": "v1"
  }
}

Note: This is a starter template. The complete workflow includes 23 nodes across 5 phases. Import this into n8n and follow the step-by-step instructions above to build the full automation system.

Complete N8N Workflow Template

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

{
  "name": "AI Listicle Content Factory",
  "nodes": [
    {
      "id": "webhook_trigger",
      "name": "Webhook Trigger",
      "type": "n8n-nodes-base.webhook",
      "position": [
        50,
        100
      ],
      "parameters": {
        "path": "listicle",
        "httpMethod": "POST",
        "responseMode": "onReceived"
      },
      "typeVersion": 2
    },
    {
      "id": "airtable_fetch_topics",
      "name": "Fetch Pending Topics from Airtable",
      "type": "n8n-nodes-base.airtable",
      "position": [
        250,
        100
      ],
      "parameters": {
        "base": "={{ $json.airtable_base_id }}",
        "table": "={{ $json.airtable_table_id }}",
        "options": {
          "filterByFormula": "={{ `NOT({Published} = 'Yes')` }}"
        },
        "resource": "record",
        "operation": "search"
      },
      "typeVersion": 2
    },
    {
      "id": "split_topics",
      "name": "Process Each Topic",
      "type": "n8n-nodes-base.splitInBatches",
      "position": [
        450,
        100
      ],
      "parameters": {
        "mode": "runOnceForEachItem"
      },
      "typeVersion": 1
    },
    {
      "id": "research_tools_gpt",
      "name": "Research Tools with GPT",
      "type": "@n8n/n8n-nodes-langchain.openAi",
      "position": [
        650,
        100
      ],
      "parameters": {
        "modelId": "gpt-4o-mini",
        "options": {},
        "messages": {
          "values": [
            {
              "role": "system",
              "content": "You are a research expert specializing in product and tool analysis. Extract key features, use cases, pricing tiers, pros/cons, and user ratings for each product/tool mentioned. Format as JSON with fields: name, features (array), useCases (array), pricing, pros (array), cons (array), userRating. Be factual and concise."
            },
            {
              "role": "user",
              "content": "Research the following tools/products for a listicle article: {{ $json.Fields.Tools }}. Extract structured information about each one."
            }
          ]
        },
        "resource": "text",
        "operation": "response"
      },
      "typeVersion": 2
    },
    {
      "id": "parse_research_data",
      "name": "Parse Research Data",
      "type": "n8n-nodes-base.code",
      "position": [
        850,
        100
      ],
      "parameters": {
        "mode": "runOnceForEachItem",
        "jsCode": "// Parse and validate research data\nconst research = $json.message;\ntry {\n  const parsed = JSON.parse(research);\n  return [{\n    research: parsed,\n    listicleTitle: $json.Fields['Listicle Title'],\n    keywords: $json.Fields.Keywords,\n    targetLength: $json.Fields['Target Word Count'] || 2000\n  }];\n} catch (e) {\n  return [{ research: { raw: research }, listicleTitle: $json.Fields['Listicle Title'], keywords: $json.Fields.Keywords }];\n}",
        "language": "javaScript"
      },
      "typeVersion": 2
    },
    {
      "id": "generate_content_claude",
      "name": "Generate Content with Claude",
      "type": "@n8n/n8n-nodes-langchain.lmChatAnthropic",
      "position": [
        1050,
        100
      ],
      "parameters": {
        "model": "claude-3-5-sonnet-20241022",
        "options": {
          "maxTokens": 4000,
          "temperature": 0.7
        },
        "messages": {
          "values": [
            {
              "role": "system",
              "content": "You are a professional content writer specializing in engaging listicles. Your task is to write high-quality, SEO-optimized listicle articles with:\n- Compelling introduction and conclusion\n- Clear item descriptions with unique insights\n- Engaging headlines for each item\n- Professional tone with conversational elements\n- Natural keyword integration\n- Proper formatting with headers and subheaders\n\nEnsure the content is original, factual, and provides real value to readers. Avoid AI clichés like 'in today's digital landscape' or 'let's dive in'."
            },
            {
              "role": "user",
              "content": "Write a listicle article:\nTitle: {{ $json.listicleTitle }}\nKeywords: {{ $json.keywords }}\nResearch Data: {{ $json.research | stringify }}\nTarget Length: {{ $json.targetLength }} words\n\nCreate a comprehensive, well-structured listicle with introduction, numbered items based on the research, and conclusion."
            }
          ]
        }
      },
      "typeVersion": 1.3
    },
    {
      "id": "quality_control_gpt",
      "name": "Quality Control & Editing Pass",
      "type": "@n8n/n8n-nodes-langchain.openAi",
      "position": [
        1250,
        100
      ],
      "parameters": {
        "modelId": "gpt-4o-mini",
        "options": {},
        "messages": {
          "values": [
            {
              "role": "system",
              "content": "You are an expert editor and quality control specialist for blog content. Review the provided listicle article and provide:\n1. Grammar and spelling corrections\n2. Readability improvements\n3. SEO optimization suggestions\n4. Fact-checking notes\n5. Engagement score (1-10)\n6. Recommended revisions\n\nFormat your response as a structured JSON with fields: corrections, improvements, seoSuggestions, factCheckNotes, engagementScore, revisedContent"
            },
            {
              "role": "user",
              "content": "Please review and edit this listicle for quality control:\n\n{{ $json.message }}\n\nTitle: {{ $previousNode.json.listicleTitle }}\nKeywords: {{ $previousNode.json.keywords }}"
            }
          ]
        },
        "resource": "text",
        "operation": "response"
      },
      "typeVersion": 2
    },
    {
      "id": "finalize_content",
      "name": "Finalize Content",
      "type": "n8n-nodes-base.code",
      "position": [
        1450,
        100
      ],
      "parameters": {
        "mode": "runOnceForEachItem",
        "jsCode": "// Parse quality control feedback and finalize content\nconst qcFeedback = $json.message;\nlet finalContent = $json.message;\n\ntry {\n  const parsed = JSON.parse(qcFeedback);\n  finalContent = parsed.revisedContent || $json.message;\n} catch (e) {\n  // If not JSON, use original content\n  finalContent = $json.message;\n}\n\nreturn [{\n  finalContent: finalContent,\n  listicleTitle: $previousNode.json.listicleTitle,\n  recordId: $previousNode.json.recordId,\n  excerpt: finalContent.substring(0, 160) + '...'\n}];",
        "language": "javaScript"
      },
      "typeVersion": 2
    },
    {
      "id": "wordpress_create_post",
      "name": "Create WordPress Draft",
      "type": "n8n-nodes-base.wordpress",
      "position": [
        1650,
        100
      ],
      "parameters": {
        "title": "={{ $json.listicleTitle }}",
        "options": {
          "status": "draft",
          "content": "={{ $json.finalContent }}",
          "excerpt": "={{ $json.excerpt }}"
        },
        "resource": "post",
        "operation": "create"
      },
      "typeVersion": 1
    },
    {
      "id": "update_airtable_success",
      "name": "Update Airtable - Success",
      "type": "n8n-nodes-base.airtable",
      "position": [
        1850,
        100
      ],
      "parameters": {
        "id": "={{ $json.recordId }}",
        "base": "={{ $json.airtable_base_id }}",
        "table": "={{ $json.airtable_table_id }}",
        "columns": {
          "Values": [
            {
              "value": "Yes",
              "column": "Published"
            },
            {
              "value": "={{ $json.id }}",
              "column": "WordPress Post ID"
            },
            {
              "value": "Draft Published",
              "column": "Status"
            },
            {
              "value": "={{ new Date().toISOString().split('T')[0] }}",
              "column": "Published Date"
            }
          ]
        },
        "resource": "record",
        "operation": "update"
      },
      "typeVersion": 2
    },
    {
      "id": "generate_summary",
      "name": "Generate Completion Summary",
      "type": "n8n-nodes-base.code",
      "position": [
        2050,
        100
      ],
      "parameters": {
        "mode": "runOnceForAllItems",
        "jsCode": "// Generate summary report\nreturn [{\n  status: 'completed',\n  totalProcessed: items.length,\n  timestamp: new Date().toISOString(),\n  message: `Successfully processed ${items.length} listicle(s) through the content factory pipeline`\n}];",
        "language": "javaScript"
      },
      "typeVersion": 2
    }
  ],
  "connections": {
    "Webhook Trigger": {
      "main": [
        [
          {
            "node": "Fetch Pending Topics from Airtable",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Finalize Content": {
      "main": [
        [
          {
            "node": "Create WordPress Draft",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Process Each Topic": {
      "main": [
        [
          {
            "node": "Research Tools with GPT",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Parse Research Data": {
      "main": [
        [
          {
            "node": "Generate Content with Claude",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Create WordPress Draft": {
      "main": [
        [
          {
            "node": "Update Airtable - Success",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Research Tools with GPT": {
      "main": [
        [
          {
            "node": "Parse Research Data",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Update Airtable - Success": {
      "main": [
        [
          {
            "node": "Generate Completion Summary",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Generate Content with Claude": {
      "main": [
        [
          {
            "node": "Quality Control & Editing Pass",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Quality Control & Editing Pass": {
      "main": [
        [
          {
            "node": "Finalize Content",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Fetch Pending Topics from Airtable": {
      "main": [
        [
          {
            "node": "Process Each Topic",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}