n8n 101: AI Workflow Automation

# Check running version
docker inspect n8n | grep -i image
# Or visit: https://your-n8n.com/rest/settings

# Upgrade (Docker)
docker pull n8nio/n8n:1.121.0
docker-compose down && docker-compose up -d

# /etc/nginx/sites-available/n8n
server {
  listen 443 ssl;
  server_name n8n.yourdomain.com;

  # Block admin REST API from non-whitelisted IPs
  location ~ ^/rest/(settings|users|credentials) {
    allow 203.0.113.10;   # your office IP
    deny all;
    proxy_pass http://localhost:5678;
  }

  # Webhooks — public
  location /webhook/ {
    proxy_pass http://localhost:5678;
    proxy_set_header X-Real-IP $remote_addr;
  }

  # Editor UI — auth required (handled by n8n)
  location / {
    proxy_pass http://localhost:5678;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
  }
}

version: '3.8'

services:
  n8n:
    image: n8nio/n8n:1.121.0         # pin version, never use 'latest' in prod
    container_name: n8n
    restart: unless-stopped
    ports:
      - "127.0.0.1:5678:5678"          # bind to localhost only
    environment:
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      - N8N_HOST=${N8N_HOST}
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=https://${N8N_HOST}
      - N8N_SECURE_COOKIE=true
      - N8N_ENFORCE_SETTINGS_FILE_PERMISSIONS=true
      - N8N_BLOCK_NODE_ACCESS=true
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=${DB_PASSWORD}
      - EXECUTIONS_DATA_PRUNE=true
      - EXECUTIONS_DATA_MAX_AGE=720        # 30 days of logs
      - GENERIC_TIMEZONE=Europe/London
    volumes:
      - ./n8n_data:/home/node/.n8n
    depends_on:
      postgres:
        condition: service_healthy

  postgres:
    image: postgres:15-alpine
    container_name: n8n_postgres
    restart: unless-stopped
    environment:
      - POSTGRES_DB=n8n
      - POSTGRES_USER=n8n
      - POSTGRES_PASSWORD=${DB_PASSWORD}
    volumes:
      - ./postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U n8n"]
      interval: 10s
      timeout: 5s
      retries: 5

#!/bin/bash
# crontab -e → 0 3 * * * /root/backup.sh

DATE=$(date +%Y%m%d-%H%M)
BACKUP_DIR=/root/backups
mkdir -p $BACKUP_DIR

docker exec n8n_postgres pg_dump -U n8n n8n > $BACKUP_DIR/n8n-db-$DATE.sql
tar -czf $BACKUP_DIR/n8n-data-$DATE.tar.gz /root/n8n_data
aws s3 cp $BACKUP_DIR/n8n-db-$DATE.sql s3://your-bucket/n8n-backups/

find $BACKUP_DIR -name "*.sql" -mtime +14 -delete
find $BACKUP_DIR -name "*.tar.gz" -mtime +14 -delete

// A node receives items — an array of objects:
[
  { "json": { "email": "alice@co.com", "score": 85 } },
  { "json": { "email": "bob@co.com",   "score": 42 } }
]

// By default, most nodes process each item independently (1-in, 1-out)
// Some nodes merge items (Summarize, Aggregate)
// Some nodes split items (Split Out, SplitInBatches)

// String interpolation
Hello {{ $json.firstName }}, your booking for {{ $json.propertyAddress }} is confirmed.

// Conditional value
{{ $json.budget >= 2000 ? 'HOT' : 'WARM' }}

// Date formatting
{{ $now.toFormat('dd MMM yyyy') }}          // "14 May 2026"
{{ $now.minus({days: 7}).toISO() }}         // 7 days ago

// Null coalescing
{{ $json.phone || 'no phone provided' }}

// Access upstream node data
{{ $node["Webhook"].json.body.email }}

// Skip side effects in test mode
{{ $execution.mode === 'manual' ? 'test@example.com' : $json.email }}

// Code node runs JS. Access all items:
const items = $input.all();

return items.map(item => {
  const { email, budget, move_in_date } = item.json;

  const daysUntil = Math.ceil(
    (new Date(move_in_date) - new Date()) / (1000 * 60 * 60 * 24)
  );

  let score = 'COLD';
  if (budget >= 2000 && daysUntil <= 30) score = 'HOT';
  else if (budget >= 1500 || daysUntil <= 60) score = 'WARM';

  return {
    json: { ...item.json, score, days_until_move_in: daysUntil }
  };
});

// After webhook, before creating records — check if already processed

HTTP Request: GET Sheets — check Processed!A:A for submission token

Code node:
const processed = $input.first().json.values?.flat() || [];
const submissionId = $node["Webhook"].json.body.token;

if (processed.includes(submissionId)) {
  return [];  // empty array stops execution — duplicate
}
return [{ json: { submission_id: submissionId, ...$node["Webhook"].json.body } }];

HTTP Request node — cursor-based pagination:
Pagination Type: Response Contains Next URL
Next URL Expression: {{ $response.body.meta.nextPageUrl }}

// Or for offset-based:
Pagination Type: Update a Parameter
Parameter Name: offset
Value: += 100
Max Pages: 50  (safety limit)
Stop When: response returns empty array

// Incoming webhook (raw, messy):
{ "lead_first_name": "Alice", "budget_pcm": "£2,500", "properties": ["flat","2-bed"] }

// Edit Fields node — reshape to schema:
fullName      = {{ $json.lead_first_name + ' ' + $json.lead_last_name }}
budget        = {{ parseInt($json.budget_pcm.replace(/[^0-9]/g, '')) }}
property_type = {{ $json.properties.join(', ') }}

// Output:
{ "fullName": "Alice Chen", "budget": 2500, "property_type": "flat, 2-bed" }

// Workflow name: [system] global error handler

Trigger: Error Trigger  ← under "Core" in node panel
  ↓
Code node — format alert:
const err = $input.first().json;
return [{
  json: {
    workflow: err.workflow.name,
    error: err.execution.error?.message,
    url: `https://your-n8n.com/workflow/${err.workflow.id}/executions/${err.execution.id}`
  }
}];
  ↓
Slack node — post to #automation-alerts:
🚨 *{{ $json.workflow }}* failed: {{ $json.error }}
  ↓
Google Sheets append — dead letter log:
Timestamp | Workflow | Error | URL | Resolved

// ENTRY POINT WORKFLOWS (triggered by external events)
[lead] webhook — GHL form            → calls → [lead] process new lead
[lead] webhook — WhatsApp inbound    → calls → [lead] process new lead

// CORE WORKFLOW (the one job)
[lead] process new lead
  ↓ calls → [util] create GHL contact
  ↓ calls → [util] send welcome email
  ↓ IF hot → calls → [alert] slack hot lead
  ↓ calls → [lead] start drip sequence

// UTILITY WORKFLOWS (reusable)
[util] create GHL contact           ← called from: 3 entry points
[util] send welcome email           ← called from: 2 workflows

// SCHEDULED WORKFLOWS
[report] weekly KPI summary         → every Monday 09:00
[maint] check dead letter queue     → every Monday 09:05

Trigger: Manual / Schedule
  ↓
Google Drive node: Get all docs from /knowledge-base folder
  ↓
Text Splitter node:
  Chunk Size: 800 tokens
  Chunk Overlap: 80 tokens (10% overlap retains context across boundaries)
  Splitter: Recursive Character
  ↓
Embeddings node: text-embedding-3-small
  ↓
Vector Store (Pinecone / Qdrant):
  Operation: Upsert
  Metadata: { source, doc_title, chunk_index, last_updated }

Input: { "query": "How do I submit a maintenance request?" }
  ↓
Embeddings node: embed the query text
  ↓
Vector Store node:
  Operation: Search | Top K: 5 | Score Threshold: 0.72
  ↓
Code node: format context
const context = $input.all()
  .filter(c => c.json.score >= 0.72)
  .map((c, i) => `[${i+1}] ${c.json.text}`)
  .join('\n\n');
  ↓
LLM node:
  System: Answer ONLY using the provided context. If not in context,
          say "I need to check on that" and return confidence: 0.3.
  User: Context:\n{{ $json.context }}\n\nQuestion: {{ $json.query }}

Step 1: Webhook — receive Slack event
  Auth: Slack request signature verification (HMAC)
  Respond: Immediately (Slack has 3s timeout)

Step 2: Code node — extract message
const text = payload.event.text.replace(/<@[^>]+>/g, '').trim();
return [{ json: { userId: payload.event.user, text, channel: payload.event.channel } }];

Step 3: Vector Search (Qdrant)
  Top K: 5 | Score Threshold: 0.70

Step 4: AI Agent
  Model: gpt-4o-mini (temperature: 0.2)
  Memory: PostgreSQL (keyed by userId)
  System:
    You are a support agent for Whitmore Property Management (UK).
    Answer ONLY using the provided knowledge base context.
    Be concise — max 150 words. Use UK English.
    If answer not in context, set confidence = 0.2 and say:
    "I'd like to check this with the team."

Step 5: IF — confidence >= 0.65?
  TRUE  → Send AI reply to user via Slack DM
  FALSE → Post to #support-escalations for human review

Step 6: Google Sheets append — log all interactions
  timestamp | user | question | response | confidence | escalated

Step 1: Webhook
  Receives: name, email, phone, property_type, budget_pcm, move_in_date, source

Step 2: LLM Node (classification only — not an agent)
  Model: gpt-4o-mini | Temperature: 0
  System: You are a lead scoring engine. Output ONLY valid JSON.
  User:
    Score this rental lead as HOT, WARM, or COLD.
    HOT:  budget >= 2000 AND days_to_move <= 30
    WARM: budget >= 1500 OR days_to_move <= 60
    COLD: all others
    Lead: {{ JSON.stringify($json) }}
    Return: { "score": "HOT|WARM|COLD", "reason": "...", "priority_action": "..." }

Step 3: Switch node
  HOT  → GHL contact + Slack alert + WhatsApp template
  WARM → GHL contact + email sequence
  COLD → GHL contact + monthly newsletter only

Step 4: Google Sheets append
  timestamp | name | email | budget | score | reason | source

// Create contact (v2 API)
POST https://services.leadconnectorhq.com/contacts/
Authorization: Bearer {{ $env.GHL_API_KEY }}
{
  "email": "{{ $json.email }}",
  "firstName": "{{ $json.first_name }}",
  "tags": ["{{ $json.score.toLowerCase() }}", "{{ $json.source_clean }}"],
  "locationId": "{{ $env.GHL_LOCATION_ID }}"
}

// Add to pipeline
POST https://services.leadconnectorhq.com/opportunities/
{
  "pipelineId": "{{ $env.GHL_PIPELINE_HOT }}",
  "pipelineStageId": "{{ $env.GHL_STAGE_NEW }}",
  "contactId": "{{ $json.contact_id }}"
}

Step 1: Webhook — receive Meta Cloud API POST
  IF $json.hub?.challenge → return challenge (text/plain)

Step 2: Extract message
const msg = $input.first().json.entry?.[0]?.changes?.[0]?.value?.messages?.[0];
if (!msg || msg.type !== 'text') return [];
return [{ json: { from: msg.from, text: msg.text.body } }];

Step 3: LLM extract — parse landlord intent
  Return JSON: { property_type, bedrooms, location, asking_rent_pcm, missing_fields }

Step 4: IF — missing required fields?
  TRUE  → Send template requesting missing info
  FALSE → Create GHL contact + send confirmation template

Send template:
POST https://graph.facebook.com/v19.0/{{ $env.WABA_PHONE_ID }}/messages
{
  "messaging_product": "whatsapp",
  "to": "{{ $json.from }}",
  "type": "template",
  "template": {
    "name": "property_details_request",
    "language": { "code": "en_GB" }
  }
}

Step 1: Schedule Trigger — Every Monday at 09:00 (Europe/London)

Step 2: HTTP Request — fetch leads from GHL (last 7 days)
  createdAfter: {{ $now.minus({days:7}).toISO() }}

Step 3: Code node — compute metrics
const contacts = $input.all().map(i => i.json);
const total     = contacts.length;
const hot       = contacts.filter(c => c.tags?.includes('lead-hot')).length;
const converted = contacts.filter(c => c.tags?.includes('converted')).length;

return [{
  json: {
    period_start: new Date(Date.now()-7*86400000).toISOString().slice(0,10),
    total, hot, converted,
    conversion_rate: total ? ((converted/total)*100).toFixed(1) : 0
  }
}];

Step 4: LLM node — 3-sentence executive summary from the numbers

Step 5: Parallel branches
  A → Google Sheets append (historical log)
  B → Email to client (SMTP)
  C → Slack to #client-reports (team quick view)

# 1. Create bot via @BotFather → /newbot → get TOKEN
# 2. Get your chat ID
curl https://api.telegram.org/botTOKEN/getUpdates

# 3. Set webhook to receive messages
curl -X POST https://api.telegram.org/botTOKEN/setWebhook \
  -d url=https://your-n8n.com/webhook/telegram \
  -d secret_token=your-secret

# 4. Send message from n8n
POST https://api.telegram.org/botTOKEN/sendMessage
{
  "chat_id": "{{ $json.chat_id }}",
  "text": "Your message here",
  "parse_mode": "Markdown"
}

POST https://slack.com/api/chat.postMessage
Authorization: Bearer {{ $env.SLACK_BOT_TOKEN }}
{
  "channel": "#hot-leads",
  "blocks": [
    {
      "type": "header",
      "text": { "type": "plain_text", "text": "🔥 Hot Lead — Action Required" }
    },
    {
      "type": "section",
      "fields": [
        { "type": "mrkdwn", "text": "*Name*\n{{ $json.fullName }}" },
        { "type": "mrkdwn", "text": "*Budget*\n£{{ $json.budget }}/mo" }
      ]
    },
    {
      "type": "actions",
      "elements": [{
        "type": "button",
        "style": "primary",
        "text": { "type": "plain_text", "text": "View in GHL" },
        "url": "https://app.gohighlevel.com/contacts/{{ $json.ghl_id }}"
      }]
    }
  ]
}

# ─── n8n core ───
N8N_ENCRYPTION_KEY=64-char-hex
N8N_HOST=n8n.yourdomain.com
DB_PASSWORD=strong-db-password

# ─── GHL ───
GHL_API_KEY_CLIENT_A=...
GHL_LOCATION_ID_CLIENT_A=...

# ─── AI ───
OPENAI_API_KEY=sk-...

# ─── channels ───
SLACK_BOT_TOKEN=xoxb-...
META_TOKEN=EAA...
TELEGRAM_BOT_TOKEN=...

# ─── email ───
SMTP_USER=ops@yourdomain.com
SMTP_PASS=gmail-app-password

services:
  n8n-main:              # handles UI + webhook reception
    image: n8nio/n8n:1.121.0
    environment:
      - EXECUTIONS_MODE=queue
      - QUEUE_BULL_REDIS_HOST=redis

  n8n-worker:           # handles workflow execution
    image: n8nio/n8n:1.121.0
    command: n8n worker --concurrency=10
    deploy:
      replicas: 3           # 3 workers × 10 = 30 parallel executions

  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes

// Auth: X-N8N-API-KEY header (create in Settings → n8n API)

// List all workflows
GET /api/v1/workflows

// Export workflow JSON (safe to git-commit)
GET /api/v1/workflows/{id}

// Bulk-set error workflow on all workflows
PATCH /api/v1/workflows/{id}
{ "settings": { "errorWorkflow": "error-handler-workflow-id" } }

// Get all failed executions for a workflow
GET /api/v1/executions?workflowId={id}&status=error&limit=20

// Trigger workflow via API
POST /api/v1/workflows/{id}/execute
{ "runData": { "Start": [{ "json": { "your": "data" } }] } }

Trigger: Schedule → Sunday 02:00
  ↓
HTTP Request: GET /api/v1/workflows
  ↓
SplitInBatches: size 1
  ↓
HTTP Request: GET /api/v1/workflows/{{ $json.id }}
  ↓
GitHub node: create/update file
  Path: workflows/{{ $json.name.replace(/[^a-z0-9]/gi,'-').toLowerCase() }}.json
  Commit: "Auto-backup {{ $json.name }} — {{ $now.toFormat('yyyy-MM-dd') }}"

# Via n8n UI (easiest)
Settings → Community Nodes → Install → enter npm package name

# Via CLI (inside Docker container)
docker exec -it n8n n8n nodes install n8n-nodes-packagename

// Current item
{{ $json.fieldName }}                      // simple field
{{ $json["field-with-dashes"] }}           // bracket notation
{{ $json.address?.city }}                  // optional chaining (safe for null)
{{ $json.items[0].name }}                  // array index
{{ $json.contact?.email || 'no email' }}   // null coalescing

// Upstream nodes
{{ $node["Webhook"].json.body.email }}
{{ $node["GHL Create"].json.id }}

// Execution context
{{ $execution.id }}           // unique run ID
{{ $execution.mode }}         // 'manual' or 'trigger'
{{ $workflow.name }}          // workflow name
{{ $itemIndex }}              // 0-based index of current item

{{ $now.toISO() }}                          // "2026-05-14T09:30:00.000Z"
{{ $now.toFormat('dd MMM yyyy') }}          // "14 May 2026"
{{ $now.toFormat('yyyy-MM-dd') }}           // "2026-05-14"
{{ $now.plus({days: 7}).toISO() }}          // 7 days from now
{{ $now.minus({months: 1}).toISO() }}       // 1 month ago
{{ $now.startOf('week').toISO() }}          // start of current week
{{ $now.endOf('month').toISO() }}           // end of current month
{{ $today }}                               // today at midnight UTC

{{ $json.name.toUpperCase() }}
{{ $json.name.trim() }}
{{ $json.name.replace(/\s+/g, '-') }}          // regex replace
{{ $json.email.split('@')[0] }}                 // split + index
{{ $json.description.substring(0, 100) + '...' }}// truncate
{{ [$json.firstName, $json.lastName].filter(Boolean).join(' ') }}

// Numbers
{{ Math.round($json.budget * 12) }}
{{ ($json.converted / $json.total * 100).toFixed(1) }}
{{ parseInt($json.budgetStr.replace(/[^0-9]/g,'')) }}

// Arrays
{{ $json.tags.length }}
{{ $json.tags.includes('vip') }}
{{ $json.tags.join(', ') }}
{{ $json.items.map(i => i.name).join(', ') }}
{{ $json.items.filter(i => i.active).length }}
{{ $json.scores.reduce((sum, s) => sum + s, 0) }}

// Conditionals
{{ $json.score >= 80 ? 'HOT' : $json.score >= 50 ? 'WARM' : 'COLD' }}
{{ $json.company || 'Individual' }}
{{ $execution.mode === 'manual' ? 'test@example.com' : $json.email }}

// Deduplicate items by field
const seen = new Set();
return $input.all().filter(item => {
  const key = item.json.email;
  if (seen.has(key)) return false;
  seen.add(key);
  return true;
});

// Array → individual items
const rows = $input.first().json.contacts;
return rows.map(row => ({ json: row }));

// Aggregate multiple items into one
const items = $input.all();
return [{ json: {
  total: items.length,
  emails: items.map(i => i.json.email),
  sum: items.reduce((s, i) => s + i.json.budget, 0)
} }];

// Safe JSON parse (handle LLM output formatting)
function safeJson(str, fallback = {}) {
  try { return JSON.parse(str.replace(/```json|```/g, '').trim()); }
  catch { return fallback; }
}
const parsed = safeJson($json.llm_output);