AI Automation Workflows: Integrate GPT with N8N

Workflow Architecture Pattern:

Trigger → Data Preparation → AI Processing → Response Handling → Action

Example Flow:
Webhook Trigger
  ↓ (receives customer email)
Extract/Clean Data
  ↓ (parse email content, metadata)
GPT Analysis
  ↓ (classify intent, generate response)
Decision Logic
  ↓ (route based on AI output)
Multiple Actions
  ↓ (send email, update CRM, log data)

In N8N, add a Webhook node with these settings:

{
  "httpMethod": "POST",
  "path": "customer-support",
  "responseMode": "onReceived",
  "options": {
    "rawBody": false
  }
}

This webhook will receive POST requests with customer inquiry data at: https://your-n8n-instance.com/webhook/customer-support

Add a Function node to structure the data for GPT analysis:

// Extract and clean customer inquiry data
const customerEmail = $input.item.json.email;
const subject = $input.item.json.subject;
const message = $input.item.json.message;
const timestamp = new Date().toISOString();

// Create structured prompt for GPT
const prompt = `Analyze this customer support inquiry and provide:
1. Primary Category (billing, technical, general, urgent)
2. Urgency Level (low, medium, high, critical)
3. Recommended Action
4. Key Topics (as array)

Customer Email: ${customerEmail}
Subject: ${subject}
Message: ${message}

Respond in JSON format only.`;

return {
  json: {
    customerEmail,
    subject,
    message,
    timestamp,
    prompt,
    originalData: $input.item.json
  }
};

Add an HTTP Request node to call OpenAI:

{
  "method": "POST",
  "url": "https://api.openai.com/v1/chat/completions",
  "authentication": "headerAuth",
  "headerAuth": {
    "name": "Authorization",
    "value": "Bearer YOUR_OPENAI_API_KEY"
  },
  "body": {
    "model": "gpt-4",
    "messages": [
      {
        "role": "system",
        "content": "You are a customer support classification AI. Always respond with valid JSON."
      },
      {
        "role": "user",
        "content": "={{ $json.prompt }}"
      }
    ],
    "temperature": 0.3,
    "response_format": { "type": "json_object" }
  }
}

Note: Store your API key in N8N's credentials manager for security. The temperature of 0.3 ensures consistent, deterministic responses for classification tasks.

Add a Function node to parse GPT's response:

// Parse GPT response
const gptResponse = JSON.parse(
  $input.item.json.choices[0].message.content
);

// Merge with original data
return {
  json: {
    ...gptResponse,
    customerEmail: $('Function').item.json.customerEmail,
    subject: $('Function').item.json.subject,
    message: $('Function').item.json.message,
    timestamp: $('Function').item.json.timestamp,
    aiProcessingTime: new Date().toISOString()
  }
};

Use a Switch node to route based on urgency:

Switch Routes:
- Route 0 (Critical): {{ $json.urgencyLevel === 'critical' }}
- Route 1 (High): {{ $json.urgencyLevel === 'high' }}
- Route 2 (Medium): {{ $json.urgencyLevel === 'medium' }}
- Route 3 (Low): {{ $json.urgencyLevel === 'low' }}

Each route can trigger different actions: critical tickets go to Slack immediately, high urgency creates priority tickets, etc.

Pattern: AI Chain Processing

Workflow Structure:
1. Topic Analysis (GPT-4)
   ↓ Extract key themes, target audience, content goals
2. Research Phase (GPT-4 + Web Search)
   ↓ Gather relevant information, current trends
3. Outline Generation (GPT-4)
   ↓ Structure content with sections
4. Content Writing (GPT-4)
   ↓ Generate full content with context
5. Quality Check (GPT-4)
   ↓ Review for accuracy, tone, completeness

// Function node: Build context from previous AI outputs
const topic = $('Webhook').item.json.topic;
const analysis = $('TopicAnalysis').item.json;
const research = $('Research').item.json;

// Create context-rich prompt
const contextualPrompt = `You are creating content about: ${topic}

AUDIENCE ANALYSIS:
${JSON.stringify(analysis.targetAudience, null, 2)}

KEY THEMES:
${analysis.themes.join(', ')}

RESEARCH INSIGHTS:
${research.insights.map(i => `- ${i}`).join('\n')}

Now write a comprehensive 1000-word article that addresses these
themes while incorporating the research insights. Use an engaging,
professional tone appropriate for the target audience.`;

return {
  json: {
    prompt: contextualPrompt,
    metadata: {
      topic,
      analysisId: analysis.id,
      researchId: research.id,
      timestamp: new Date().toISOString()
    }
  }
};

Implementing Retry Logic:

// Configure on HTTP Request node
{
  "retry": {
    "maxRetries": 3,
    "retryInterval": 2000
  },
  "timeout": 30000
}

// Add error handling in Function node
try {
  const response = $input.item.json;

  if (!response.choices || !response.choices[0]) {
    throw new Error('Invalid AI response format');
  }

  const content = response.choices[0].message.content;

  // Validate JSON if expected
  if (response.response_format?.type === 'json_object') {
    JSON.parse(content); // Throws if invalid
  }

  return { json: { success: true, content } };

} catch (error) {
  return {
    json: {
      success: false,
      error: error.message,
      timestamp: new Date().toISOString(),
      requiresManualReview: true
    }
  };
}

• Token Management: Use GPT-3.5-turbo for simple tasks, reserve GPT-4 for complex reasoning. Track token usage with a Function node after each AI call.
• Response Caching: Cache common AI responses in Redis or N8N's database to avoid redundant API calls. Especially useful for classification or FAQ-style queries.
• Prompt Optimization: Shorter, more specific prompts reduce token costs. Test different prompt structures to find the most efficient version that maintains quality.
• Batch Processing: When possible, batch multiple items into a single AI request rather than making individual calls for each item.

// Function node: Track and log token usage
const response = $input.item.json;
const usage = response.usage;

// Calculate cost (example rates)
const costPer1kTokens = {
  'gpt-4': { prompt: 0.03, completion: 0.06 },
  'gpt-3.5-turbo': { prompt: 0.0015, completion: 0.002 }
};

const model = response.model;
const promptCost = (usage.prompt_tokens / 1000) * costPer1kTokens[model].prompt;
const completionCost = (usage.completion_tokens / 1000) * costPer1kTokens[model].completion;
const totalCost = promptCost + completionCost;

return {
  json: {
    ...response,
    costTracking: {
      promptTokens: usage.prompt_tokens,
      completionTokens: usage.completion_tokens,
      totalTokens: usage.total_tokens,
      estimatedCost: totalCost.toFixed(4),
      model,
      timestamp: new Date().toISOString()
    }
  }
};

Issue: "Invalid JSON Response from GPT"

Cause: GPT sometimes adds markdown formatting or explanatory text

Solution:

// Add this parsing logic
let content = response.choices[0].message.content;

// Remove markdown code blocks if present
content = content.replace(/```json\n?/g, '').replace(/```\n?/g, '');

// Extract JSON if embedded in text
const jsonMatch = content.match(/\{[\s\S]*\}/);
if (jsonMatch) {
  content = jsonMatch[0];
}

const parsed = JSON.parse(content);

Issue: "Rate Limit Exceeded"

Cause: Too many API requests in short timeframe

Solutions:

• Implement exponential backoff retry strategy
• Add a rate limiter node before AI calls (limit to X requests per minute)
• Use N8N's built-in rate limiting features
• Consider upgrading your OpenAI tier for higher limits

Issue: "Inconsistent AI Responses"

Cause: High temperature settings or vague prompts

Solutions:

• Lower temperature to 0.1-0.3 for consistent outputs
• Use structured prompts with clear formatting requirements
• Add example outputs in your system message
• Use response_format: json_object when possible

Example: Smart Model Router

// Function node: Route to appropriate AI model
const task = $input.item.json;
const complexity = task.estimatedComplexity || 'medium';
const length = task.content?.length || 0;

let modelConfig;

if (complexity === 'high' || length > 2000) {
  modelConfig = {
    model: 'gpt-4',
    endpoint: 'openai',
    maxTokens: 4000
  };
} else if (task.type === 'classification') {
  modelConfig = {
    model: 'gpt-3.5-turbo',
    endpoint: 'openai',
    maxTokens: 500,
    temperature: 0.2
  };
} else {
  modelConfig = {
    model: 'gpt-3.5-turbo',
    endpoint: 'openai',
    maxTokens: 1500
  };
}

return { json: { ...task, modelConfig } };

// HTTP Request node configuration for streaming
{
  "method": "POST",
  "url": "https://api.openai.com/v1/chat/completions",
  "body": {
    "model": "gpt-4",
    "messages": [...],
    "stream": true
  }
}

// Handle stream in Function node
const chunks = [];
const stream = $input.item.binary.data;

// Process stream chunks
for await (const chunk of stream) {
  const data = chunk.toString();
  if (data.startsWith('data: ')) {
    const json = JSON.parse(data.slice(6));
    if (json.choices[0].delta.content) {
      chunks.push(json.choices[0].delta.content);
      // Emit to websocket or SSE endpoint
    }
  }
}

return { json: { fullResponse: chunks.join('') } };