DEV Community: Raizan

Building a Crypto Price Alert Bot with n8n and CoinGecko

Raizan — Wed, 29 Apr 2026 08:00:29 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for self-hosting
Namecheap if setting up a domain
CoinGecko API (free tier available at coingecko.com)
A messaging platform (Discord, Telegram, or email)

What You'll Need
Understanding the Architecture
Setting Up Your First Webhook Trigger
Fetching Live Crypto Prices from CoinGecko
Building the Price Alert Logic
Sending Notifications
Getting Started

Understanding the Architecture

I've been building crypto automation workflows for about two years now, and I can tell you: price alert bots are deceptively simple on the surface but incredibly powerful when done right. The basic architecture is straightforward: a trigger fires on a schedule, you fetch current prices, compare them against thresholds you've set, and notify the user if conditions are met.

Here's what happens behind the scenes:

Trigger: A schedule executes every N minutes
Data fetch: Call CoinGecko API for real-time prices
Logic: Compare prices against your alert thresholds
Action: Send a notification if the alert fires

The beauty of building this in n8n Cloud is that you get a visual workflow editor, built-in nodes for HTTP requests, and native integrations with Discord, Telegram, and email—no custom code required (though you can add it if you want).

If you're deploying to production, you might consider self-hosting n8n on a Hetzner VPS or learning how to deploy n8n with Docker on any VPS. That gives you full control over execution and cost savings at scale.

Setting Up Your First Webhook Trigger

Log into n8n Cloud and create a new workflow. The first node will be your trigger—I'm using a Schedule node set to run every 5 minutes.

Click the + icon on your canvas and search for "Schedule". Add the node and configure it like this:

Trigger Type: Every X minutes
Interval: 5

This means your workflow will execute every 5 minutes automatically. You could also use a Webhook trigger if you want external systems to kick off the workflow, but for a price alert bot, a schedule makes more sense—you want continuous monitoring, not event-driven checks.

Now connect your Schedule node to your next step. We're going to fetch live price data.

Fetching Live Crypto Prices from CoinGecko

The CoinGecko API is free and doesn't require authentication for basic endpoints. This is crucial because it means zero setup friction. Add an HTTP Request node right after your Schedule trigger.

Configure the HTTP node like this:

Node: HTTP Request

Method: GET
URL: https://api.coingecko.com/api/v3/simple/price
Authentication: None
Query Parameters:
  ids: bitcoin,ethereum,cardano
  vs_currencies: usd
  include_market_cap: true
  include_24hr_vol: true
  include_24hr_change: true

The response will look like:

{
  "bitcoin": {
    "usd": 42150,
    "usd_market_cap": 831000000000,
    "usd_24h_vol": 24000000000,
    "usd_24h_change": 2.5
  },
  "ethereum": {
    "usd": 2250,
    "usd_market_cap": 270000000000,
    "usd_24h_vol": 9000000000,
    "usd_24h_change": 1.8
  },
  "cardano": {
    "usd": 0.95,
    "usd_market_cap": 33000000000,
    "usd_24h_vol": 450000000,
    "usd_24h_change": -0.5
  }
}

This single API call gives you everything you need. You can request as many coins as you want in the ids parameter—just separate them with commas. For a comprehensive list of supported coins, check the best free APIs for building automation workflows in 2026 guide, which includes CoinGecko benchmarks.

Building the Price Alert Logic

Now we need to add logic. You'll want to store your alert thresholds somewhere—for this example, I'm storing them in a Function node as JavaScript, but in production, you'd use a database or external config file.

Add a Function node after your HTTP Request node:

const priceData = $input.all()[0].json;
const alerts = [
  { coin: "bitcoin", targetPrice: 40000, direction: "below" },
  { coin: "ethereum", targetPrice: 2000, direction: "below" },
  { coin: "cardano", targetPrice: 0.80, direction: "below" }
];

const triggeredAlerts = [];

for (const alert of alerts) {
  const currentPrice = priceData[alert.coin].usd;

  if (alert.direction === "below" && currentPrice < alert.targetPrice) {
    triggeredAlerts.push({
      coin: alert.coin.toUpperCase(),
      currentPrice: currentPrice,
      targetPrice: alert.targetPrice,
      change24h: priceData[alert.coin].usd_24h_change
    });
  } else if (alert.direction === "above" && currentPrice > alert.targetPrice) {
    triggeredAlerts.push({
      coin: alert.coin.toUpperCase(),
      currentPrice: currentPrice,
      targetPrice: alert.targetPrice,
      change24h: priceData[alert.coin].usd_24h_change
    });
  }
}

return triggeredAlerts;

This function compares each coin's current price against your thresholds. It supports both "above" and "below" directions, so you can alert on pumps or dumps. The output is an array of triggered alerts—empty if no alerts fire.

Next, add an IF node to check if any alerts were triggered:

Condition: triggeredAlerts.length > 0

If this evaluates to true, proceed to your notification nodes. If false, the workflow ends silently—no spam.

Sending Notifications

Connect your IF node to a Discord node (or Telegram/email—your choice). I'll show Discord because it's the most popular for crypto communities.

Add a Discord node and configure it:

Node: Discord

Authentication: Select your Discord webhook
Message Type: Text
Text:
🚨 CRYPTO PRICE ALERT 🚨

{{ $json[0].coin }} just hit your target!
Current Price: ${{ $json[0].currentPrice }}
Target Price: ${{ $json[0].targetPrice }}
24h Change: {{ $json[0].change24h }}%

Action now or miss the move! 📈

The $json[0] syntax references data from the previous node. For multiple alerts in one message, you'd loop through the array. Here's a more advanced version using a Code node to format multiple alerts:

Node: Function (for formatting)

const alerts = $input.all()[0].json;

let message = "🚨 **CRYPTO PRICE ALERTS** 🚨\n\n";

for (const alert of alerts) {
  message += `**${alert.coin}**\n`;
  message += `Current: $${alert.currentPrice}\n`;
  message += `Target: $${alert.targetPrice}\n`;
  message += `24h Change: ${alert.change24h.toFixed(2)}%\n\n`;
}

message += "Check your exchange now! ⚡";

return { message: message };

Then pass {{ $json.message }} to your Discord node's Text field.

If you want text-to-speech notifications on mobile, consider piping alerts through Edge TTS: The Free Text-to-Speech Engine, which integrates beautifully with n8n for voice alerts.

Advanced: Multi-Exchange Price Comparison

If you want to level up, fetch prices from multiple exchanges and alert when spreads widen. Add a second HTTP Request node that calls a different endpoint:

Method: GET
URL: https://api.coingecko.com/api/v3/simple/price
Query Parameters:
  ids: bitcoin,ethereum
  vs_currencies: usd
  include_exchanges: true

Then use a Function node to calculate spreads:

const prices = $input.all()[0].json;

const analysis = {
  bitcoin: {
    current: prices.bitcoin.usd,
    volatility: prices.bitcoin.usd_24h_change
  },
  ethereum: {
    current: prices.ethereum.usd,
    volatility: prices.ethereum.usd_24h_change
  }
};

if (analysis.bitcoin.volatility > 5) {
  return { alert: true, message: `Bitcoin is volatile (${analysis.bitcoin.volatility}%)` };
}

return { alert: false };

This triggers alerts on high volatility, not just price thresholds—much smarter for active traders.

Error Handling & Rate Limiting

CoinGecko's free API allows 10-50 calls per minute depending on your region. With a 5-minute schedule and a single endpoint, you're safe. But add error handling anyway:

try {
  const response = $input.all()[0].json;
  if (!response.bitcoin) throw new Error("API returned incomplete data");
  return response;
} catch (error) {
  return { error: error.message, timestamp: new Date().toISOString() };
}

Then add an IF node that checks for error in the response and sends you a Slack message if something breaks.

Getting Started

Ready to build? Here's your action plan:

Sign up for n8n Cloud (free tier covers most use cases)
Create a new workflow
Add Schedule → HTTP Request → Function → IF → Discord/Telegram node
Test with manual trigger (click the play button)
Adjust alert thresholds based on your trading strategy
Turn on Active toggle to run your bot 24/7

If you're planning to run this bot constantly without cloud costs, explore deploying n8n with Docker on a Hetzner VPS—you'll pay ~$3-5/month instead of n8n Cloud's subscription.

Outsource Your Automation

Don't have time to build this yourself? I specialize in production-ready n8n workflows, WhatsApp bots, and fully automated YouTube Shorts pipelines. Hire me on Fiverr—mention SYS3-DEVTO for priority handling and 20% off. Or reach out directly at chasebot.online and let's discuss your specific needs.

I've built crypto bots that handle multi-exchange arbitrage, Discord raid alerts, and even automated position management. Whatever you're trying to automate, I can make it work.

Pro tip: Save your workflow

Originally published on Automation Insider.

How to Use HuggingFace Inference API for Free Image Generation

Raizan — Tue, 28 Apr 2026 08:00:29 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for hosting
Namecheap if domain needed
A free HuggingFace account (huggingface.co)
Basic understanding of API calls and JSON

Understanding HuggingFace Inference API
Setting Up Your API Key
Making Your First Free Image Generation Request
Integrating with n8n for Automated Workflows
Handling Rate Limits and Optimization
Getting Started

Understanding HuggingFace Inference API

I've been working with AI model APIs for the past three years, and HuggingFace's approach is genuinely refreshing. Their Inference API lets you hit thousands of pre-trained models—including cutting-edge image generation models like Stable Diffusion—completely free. The catch? You get rate limits, but for personal projects and testing, it's more than enough.

HuggingFace hosts model inference behind their API servers. You send a prompt, they run it on their GPU infrastructure, and return the generated image. No setup, no hardware needed on your end. The free tier covers text-to-image, image-to-image, image classification, and dozens of other tasks.

The models you're accessing are open-source, maintained by the community. You're not locked into proprietary offerings like DALL-E. That means you can iterate, test, and deploy without vendor anxiety.

Setting Up Your API Key

First, head to HuggingFace and create a free account if you don't have one. Once you're logged in, navigate to your Settings page (click your profile icon in the top right).

Look for "Access Tokens" in the left sidebar. Click "Create new token" and give it a name—something like "Image Generation Workflow." Set the token type to "read" (you don't need write access for inference). Copy the token immediately and store it somewhere safe. You won't see it again.

Now you have your authentication. This token is what authorizes your API calls to HuggingFace's servers.

Making Your First Free Image Generation Request

Let me show you exactly how to hit the API from the command line. This is the foundation for everything else.

curl https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-3.5-large \
  -X POST \
  -H "Authorization: Bearer YOUR_API_TOKEN_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": "A serene mountain landscape at sunset with golden light reflecting off a calm lake"
  }' \
  --output generated_image.png

Replace YOUR_API_TOKEN_HERE with the token you just created. This command sends a prompt to Stable Diffusion 3.5 Large and downloads the resulting image as PNG.

The first request takes 10-15 seconds because the model needs to load. Subsequent requests are faster. You'll get raw image binary back, which the --output flag saves as a file.

Here's a Python example if you prefer working in code:

import requests
import json

HF_API_TOKEN = "YOUR_API_TOKEN_HERE"
MODEL_ID = "stabilityai/stable-diffusion-3.5-large"
API_URL = f"https://api-inference.huggingface.co/models/{MODEL_ID}"

headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}

payload = {
    "inputs": "A cyberpunk city street at night with neon signs and flying cars"
}

response = requests.post(API_URL, headers=headers, json=payload)

if response.status_code == 200:
    with open("generated_image.png", "wb") as f:
        f.write(response.content)
    print("Image saved successfully")
else:
    print(f"Error: {response.status_code}")
    print(response.json())

This script does the exact same thing but lets you handle the response programmatically. You can check for errors, log responses, and chain it into larger workflows.

Integrating with n8n for Automated Workflows

Now here's where it gets interesting. n8n Cloud lets you build no-code automation that can generate images on demand. Instead of running curl commands manually, you set up a workflow that generates images based on webhooks, database triggers, or scheduled intervals.

Create a new workflow in n8n and add an HTTP Request node. Configure it like this:

HTTP Request Node Configuration:

Method: POST
URL: https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-3.5-large
Authentication: Header
Headers:
- Authorization: Bearer YOUR_API_TOKEN_HERE
- Content-Type: application/json

In the Body section, set it to JSON and add:

{
  "inputs": "{{ $node.previous_node.json.prompt }}"
}

This assumes you have a previous node passing a prompt field. If you're triggering this with a webhook, your webhook node would receive JSON like:

{
  "prompt": "A minimalist Scandinavian bedroom with soft morning light"
}

The {{ $node.previous_node.json.prompt }} syntax pulls that value and inserts it into the API request.

After the HTTP Request node, add a Binary File node set to "Write Binary File" to save the image:

{
  "fileName": "{{ $execution.id }}_{{ Date.now() }}.png",
  "directoryPath": "/tmp/generated_images"
}

This creates a unique filename for each generated image using the execution ID and timestamp.

To trigger this workflow from external tools, add a Webhook trigger node at the start. Configure it to POST and copy the webhook URL. Now you can send image generation requests from any application.

Here's a complete request you could send:

curl https://YOUR_N8N_WEBHOOK_URL \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "An underwater coral reef with bioluminescent creatures"
  }'

Your n8n workflow receives the prompt, hits HuggingFace, gets the image, saves it, and returns a success response.

If you're comparing automation platforms, you should know that n8n vs Make vs Zapier: Honest Comparison for 2026 shows n8n's HTTP nodes are more flexible for API work like this. Make.com requires API extensions for binary handling, while n8n handles it natively.

Handling Rate Limits and Optimization

HuggingFace's free tier doesn't publish exact rate limits, but I've consistently hit around 5 requests per second without throttling. Beyond that, you'll get 503 Service Unavailable responses.

Here's how to handle rate limiting gracefully in n8n:

Add a Wait node after your HTTP Request node with this configuration:

{
  "type": "fixed_time",
  "waitDuration": 0.2
}

This adds a 200ms delay between requests, keeping you well under the 5 RPS limit. If you're generating multiple images in a loop, this is crucial.

For production workflows, add retry logic. In the HTTP Request node, set:

Retry on fail: Enabled
Max retries: 3
Retry delay: 1000ms (1 second)

This handles temporary API hiccups without breaking your workflow.

If you need multiple images or advanced processing, consider piping generated images through ffmpeg for Content Creators: Essential Commands Cheat Sheet to resize, compress, or batch-process them.

Model Selection Matters

Different models have different speed/quality tradeoffs:

stabilityai/stable-diffusion-3.5-large: Best quality, slower, great for high-detail prompts
stabilityai/stable-diffusion-xl-base-1.0: Faster, excellent quality, best overall balance
black-forest-labs/FLUX.1-schnell: Fastest inference, sharp results, smaller memory footprint

I use FLUX.1-schnell for rapid prototyping and SD 3.5 Large when quality matters.

Getting Started

Set up your HuggingFace API key today, test a single curl request, then move it into n8n Cloud. Start with a webhook-triggered workflow that generates one image per request. Scale from there.

If you're building lead capture pipelines alongside your image generation, check out Building a Lead Capture System with n8n and Typeform to capture requests and metadata alongside your generated images.

For self-hosting, use Hetzner VPS or Contabo VPS and install n8n via Docker. You can store generated images in a local directory or push them to cloud storage.

Outsource Your Automation

Don't have time? I build production n8n workflows, WhatsApp bots, and fully automated YouTube Shorts pipelines. Hire me on Fiverr — mention SYS3-DEVTO for priority. Or DM at chasebot.online.

Originally published on Automation Insider.

pm2 Process Manager: Keep Your Node.js Bots Running Forever

Raizan — Mon, 27 Apr 2026 08:00:27 +0000

What You'll Need

n8n Cloud or self-hosted n8n (for orchestrating automated workflows)
Hetzner VPS or Contabo VPS for hosting your Node.js processes
DigitalOcean as an alternative hosting provider
Node.js 18+ installed locally and on your server
SSH access to your VPS
PM2 (we'll install this together)
A text editor (VS Code recommended)

Why PM2 Matters for Bot Automation
Installation & Initial Setup
Running Your First Process
Clustering & Load Balancing
Monitoring & Logs in Real-Time
Auto-Restart on Server Reboot
Integration with n8n Webhooks
Getting Started

Why PM2 Matters for Bot Automation

I learned this the hard way. Three years ago, I deployed a Node.js bot to a VPS—no process manager. It crashed at 2 AM on a Sunday, sat dead for six hours, and tanked the entire automation pipeline. That was the day I discovered PM2.

If you're running Node.js applications in production—whether it's a webhook listener for n8n automation, a Telegram bot, a Discord integration, or a custom API server—you need process management. PM2 is the industry standard because it:

Restarts crashed processes automatically (no manual intervention)
Clusters your app across CPU cores (load balancing built-in)
Manages logs (no more digging through syslog)
Survives server reboots (auto-start on startup)
Monitors memory and CPU (alerts when things go wrong)
Handles zero-downtime deployments (reload without dropping connections)

When you're building automation workflows that depend on external services, uptime isn't optional. Unlike managed platforms, a VPS doesn't come with built-in process monitoring. PM2 fills that gap for under $5/month in hosting costs (plus zero subscription fees).

Installation & Initial Setup

SSH into your server and install PM2 globally:

sudo npm install -g pm2

Verify the installation:

pm2 --version

You should see version 5.x or higher. Next, create a directory for your bot project:

mkdir -p ~/projects/automation-bot
cd ~/projects/automation-bot
npm init -y

Install Express and Axios as dependencies (we'll use these for webhook handling):

npm install express axios dotenv

Now create your first .env file to store configuration:

cat > .env << 'EOF'
PORT=3001
NODE_ENV=production
N8N_WEBHOOK_URL=https://your-n8n-instance.com/webhook/automation
LOG_LEVEL=info
EOF

Running Your First Process

Let me show you a real example. This is a simple Express server that listens for webhooks and triggers actions. Create app.js:

const express = require('express');
const axios = require('axios');
require('dotenv').config();

const app = express();
const PORT = process.env.PORT || 3001;

app.use(express.json());

// Health check endpoint
app.get('/health', (req, res) => {
  res.status(200).json({ status: 'ok', timestamp: new Date().toISOString() });
});

// Webhook endpoint
app.post('/webhook/event', async (req, res) => {
  try {
    const { event_type, data } = req.body;

    console.log(`[${new Date().toISOString()}] Received event: ${event_type}`);

    // Send to n8n webhook
    const response = await axios.post(process.env.N8N_WEBHOOK_URL, {
      event_type,
      data,
      received_at: new Date().toISOString(),
      server_hostname: require('os').hostname()
    });

    res.status(200).json({ 
      success: true, 
      message: 'Event processed',
      n8n_response: response.status 
    });
  } catch (error) {
    console.error(`[ERROR] ${error.message}`);
    res.status(500).json({ 
      success: false, 
      error: error.message 
    });
  }
});

// Error handling middleware
app.use((err, req, res, next) => {
  console.error('Unhandled error:', err);
  res.status(500).json({ error: 'Internal server error' });
});

app.listen(PORT, () => {
  console.log(`[${new Date().toISOString()}] Server running on port ${PORT}`);
  console.log(`Health check: http://localhost:${PORT}/health`);
});

// Graceful shutdown
process.on('SIGTERM', () => {
  console.log('SIGTERM received, shutting down gracefully');
  process.exit(0);
});

Now start this with PM2:

pm2 start app.js --name "webhook-bot"

Check the status:

pm2 status

You'll see output like:

┌─────┬──────────────┬─────────────┬──────┬────────┬──────────┐
│ id  │ name         │ namespace   │ mode │ status │ restart  │
├─────┼──────────────┼─────────────┼──────┼────────┼──────────┤
│ 0   │ webhook-bot  │ default     │ fork │ online │ 0        │
└─────┴──────────────┴─────────────┴──────┴────────┴──────────┘

Test it:

curl -X POST http://localhost:3001/webhook/event \
  -H "Content-Type: application/json" \
  -d '{"event_type":"test","data":{"message":"hello"}}'

Clustering & Load Balancing

Here's where PM2 gets powerful. Instead of running a single process, you can spawn one worker per CPU core. This means if your server has 4 cores, PM2 will automatically load-balance across 4 instances of your app.

Create an ecosystem.config.js file in your project root:

module.exports = {
  apps: [
    {
      name: 'webhook-bot',
      script: './app.js',
      instances: 'max',
      exec_mode: 'cluster',
      env: {
        NODE_ENV: 'production',
        PORT: 3001
      },
      merge_logs: true,
      autorestart: true,
      watch: false,
      max_memory_restart: '500M',
      error_file: './logs/err.log',
      out_file: './logs/out.log',
      log_date_format: 'YYYY-MM-DD HH:mm:ss Z'
    }
  ]
};

Stop the current process and restart using this config:

pm2 stop webhook-bot
pm2 start ecosystem.config.js

Check the cluster:

pm2 status

Now you'll see multiple instances (one per core):

┌─────┬──────────────┬─────────────┬──────────┬────────┬──────────┐
│ id  │ name         │ namespace   │ mode     │ status │ restart  │
├─────┼──────────────┼─────────────┼──────────┼────────┼──────────┤
│ 0   │ webhook-bot  │ default     │ cluster  │ online │ 0        │
│ 1   │ webhook-bot  │ default     │ cluster  │ online │ 0        │
│ 2   │ webhook-bot  │ default     │ cluster  │ online │ 0        │
│ 3   │ webhook-bot  │ default     │ cluster  │ online │ 0        │
└─────┴──────────────┴─────────────┴──────────┴──────────┴──────────┘

This is key for production. If one instance crashes, PM2 auto-restarts it while the others keep handling requests. When you're comparing automation platforms—whether it's n8n vs Make vs Zapier—self-hosted solutions like n8n running on your own VPS require this kind of reliability layer.

Monitoring & Logs in Real-Time

Watch all your processes in a dashboard:

pm2 monit

This shows CPU, memory, requests per minute, and restart counts. Press q to exit.

View logs for a specific app:

pm2 logs webhook-bot

Or tail the last 100 lines:

pm2 logs webhook-bot --lines 100

For a broader view of what's happening, save all logs to files. The ecosystem.config.js I provided earlier already does this. Check your logs:

tail -f ~/projects/automation-bot/logs/out.log

You can also rotate logs automatically. Install the PM2 logrotate module:

pm2 install pm2-logrotate

Configure it to keep logs under 10MB:

pm2 set pm2-logrotate:max_size 10M
pm2 set pm2-logrotate:retain 7

This keeps your disk clean—critical when you're running high-volume webhook receivers on a budget VPS like Hetzner or Contabo.

Auto-Restart on Server Reboot

If your VPS restarts (whether planned or due to a crash), PM2 needs to resurrect your processes. We do this by creating a startup script:

pm2 startup

This command outputs a line you need to run. It looks like:

sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u ubuntu --hp /home/ubuntu

Copy and run that exact line. Then save your current process list:

pm2 save

Now test it. Reboot your server:

sudo reboot

Wait 30 seconds, SSH back in, and check:

pm2 status

Your processes should be running. If they're not, check the systemd service:

systemctl status pm2-ubuntu

Integration with n8n Webhooks

This is where it gets practical. When you're running a self-hosted n8n instance, you often need a separate Node.js service to handle incoming webhooks and trigger workflows. PM2 keeps that service alive.

Here's a real workflow: your PM2-managed bot listens on port 3001, receives events, and hits your n8n webhook to trigger an automation.

Modify your .env:

cat > .env << 'EOF'
PORT=3001
NODE_ENV=production
N8N_WEBHOOK_URL=https://your-n8n-domain.com/webhook/

Originally published on Automation Insider.

Automating Social Media Posts with n8n: Complete Guide

Raizan — Sun, 26 Apr 2026 08:00:31 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for self-hosted deployments
Namecheap if you're setting up a custom domain
Social media platform API credentials (Twitter/X, Instagram, Facebook, LinkedIn, TikTok)
Basic understanding of REST APIs and JSON

Why Automate Social Media Posts?
Setting Up Your n8n Instance
Connecting Your First Social Platform
Building a Multi-Platform Workflow
Scheduling Posts with Cron Triggers
Advanced: Content Batching and Analytics
Getting Started

Why Automate Social Media Posts?

I've been managing social media for clients for years, and I can tell you: manually posting to six different platforms every single day is a guaranteed way to burn out. The repetition is soul-crushing. You write something once, then copy-paste it five more times with slight tweaks for platform best practices. It's mindless work—exactly what automation exists to solve.

When you automate social media posting, you free up hours every week. You can batch-create content on Monday, set it to post across the entire month, and actually focus on strategy. You can also maintain consistency (posting at optimal times in different timezones), reduce human error, and scale your reach without hiring a full social media team.

n8n makes this possible because it's flexible. Unlike many social media management tools that lock you into their limited feature set and charge per platform, n8n lets you connect any platform's API directly, chain complex logic, and build custom workflows tailored to your exact needs.

Setting Up Your n8n Instance

You've got two paths: cloud or self-hosted.

Cloud is fastest: Sign up at n8n Cloud, get a free tier with up to 1,000 executions/month, and start immediately. If you hit limits, you can upgrade or move to self-hosted without rewriting your workflows.

Self-hosted gives you full control: Deploy on a Hetzner VPS or Contabo VPS (both around $5-10/month), then use Docker to spin up n8n. You'll want to set up an Nginx reverse proxy with SSL from Let's Encrypt so your instance runs securely under a custom domain.

For this guide, I'll assume you're using n8n Cloud, but the workflows are identical whether you're cloud or self-hosted.

Connecting Your First Social Platform

Let's start with Twitter/X because its API is straightforward.

Step 1: Get Your Twitter/X API Credentials

Go to the Twitter Developer Portal
Create a new app (or use an existing one)
Generate API keys and access tokens under "Keys and tokens"
Copy:
- API Key (Consumer Key)
- API Secret (Consumer Secret)
- Access Token
- Access Token Secret

Step 2: Create Your n8n Workflow

Start with a Trigger node. Click the "+" to add a node, then search for "Manual Trigger" and add it. This lets you test the workflow by hand before scheduling it.

Now add a Twitter Node. Click "+" again, search for "Twitter," and select it. A credential dialog will pop up.

Fill in your Twitter credentials:

API Key
API Secret
Access Token
Access Token Secret

Leave the API Version as "v2" (the current standard).

Click "Create new credential" and save.

In the Twitter node itself, configure:

Operation: Post a Tweet
Text: Enter your test post, e.g., "Testing automation with n8n! 🚀"

Connect the Manual Trigger to the Twitter node. Click "Execute Workflow" at the top right.

If everything's set up correctly, you'll see a green checkmark and your tweet will post live to your account.

Building a Multi-Platform Workflow

Now let's post to multiple platforms at once. I'll add Instagram, LinkedIn, and TikTok to the same workflow.

First, gather credentials for each platform:

Instagram: Create a Facebook app, generate a Page Access Token, and use the Instagram Graph API
LinkedIn: Register an app, request the Share on behalf of a user permission
TikTok: Create a developer account, get your Access Token from the TikTok for Business API

Create a unified workflow:

Start with a Manual Trigger node (same as before). Then add a Set node to store your post content in a variable so you only write it once.

{
  "postText": "Excited to announce our new product feature! 🎉 Now available to all users.",
  "hashtags": "#automation #n8n #workflow",
  "scheduledFor": "2024-01-15T14:00:00Z"
}

Click the Set node, then "Add Data" and paste that JSON. This becomes $json for downstream nodes.

Now add your first social platform node. Right-click and duplicate it multiple times—one for each platform.

Twitter Node Config:

Operation: Post a Tweet
Text: {{ $json.postText + " " + $json.hashtags }}

LinkedIn Node Config:

Operation: Create Post
Text: {{ $json.postText + " " + $json.hashtags }}
Share Publicly: True

Instagram Node Config:

Operation: Create Media
Image URL: Point to an image (we'll use a placeholder for now: https://via.placeholder.com/1080x1080)
Caption: {{ $json.postText + " " + $json.hashtags }}

TikTok Node Config:

Operation: Create Post
Video URL: Point to a video source
Description: {{ $json.postText }}

Connect all nodes in parallel (not in sequence). Right-click the Set node, choose "Duplicate," and connect each social node to a separate duplicate of the Set node. This way, if one platform fails, the others still execute.

Click "Execute Workflow." You should see posts appear across all four platforms simultaneously.

Scheduling Posts with Cron Triggers

Manually clicking "Execute" every time you want to post defeats the purpose. Let's use a Cron trigger to automate posting on a schedule.

Delete the Manual Trigger node. Click "+" and search for "Cron." Add it.

Configure the Cron node:

Trigger Times: Select "Every day"
Time: Set to 9:00 AM (or whenever you want to post)

Your workflow now posts automatically every single day at 9 AM.

But there's a problem: you're posting the same content every day. Let's fix that with a Google Sheets connection to store different posts for each day.

Add a Google Sheets node before your social platform nodes:

Operation: Read rows
Spreadsheet: Create a Google Sheet with columns: Date, Post Text, Hashtags, Image URL
Range: A1:D31 (covers a month of posts)

The Google Sheets node outputs rows as an array. Add an Item Lists node to extract just today's row:

Operation: Limit items
Max items: 1
Offset: Current day of month (use {{ moment().date() - 1 }} to zero-index)

Now your Set node reads from the Google Sheet row:

{
  "postText": "{{ $json[0].fields['Post Text'] }}",
  "hashtags": "{{ $json[0].fields.Hashtags }}",
  "imageUrl": "{{ $json[0].fields['Image URL'] }}"
}

Connect that to your social media nodes. Every day at 9 AM, n8n reads today's row from your spreadsheet and posts it across all platforms.

You can also schedule different post times for different platforms by adding Delay nodes:

{
  "delay": 300000
}

(That's 5 minutes in milliseconds.) This staggers posts so Twitter posts at 9 AM, Instagram at 9:05 AM, etc., which looks more natural and avoids algorithm penalties.

Advanced: Content Batching and Analytics

Now let's level up. I recommend combining this with a lead capture system using Typeform to gather post ideas from your audience directly. Then you can auto-generate content based on what people actually want to see.

You can also add analytics by connecting a Webhook to a Google Sheet or database. After posting, grab the post ID from each platform, then periodically query their APIs for engagement metrics (likes, shares, comments).

Here's a webhook config to log post results:

{
  "postId": "{{ $json.id }}",
  "platform": "twitter",
  "timestamp": "{{ now().toISO() }}",
  "text": "{{ $json.postText }}",
  "status": "success"
}

Send this to a Webhook by Zapier or a custom webhook endpoint. Store the data in Google Sheets or a database, and after 7 days, query back with a HTTP Request node to fetch performance:

GET https://api.twitter.com/2/tweets/{{ $json.postId }}/metrics?metrics=public_metrics

This lets you build a real-time dashboard showing which posts performed best, so you can tailor future content.

If you're managing multiple accounts or clients, you might want to add a Split In Batches node to loop through different credential sets, so each client's posts go to their own accounts without mixing data. Similar logic applies if you're automating an email newsletter—you can trigger sends based on the same schedule.

Getting Started

Next steps:

Sign up for n8n Cloud (free tier available)
Get API credentials from your social platforms
Build your first single-platform workflow (start with Twitter/X)
Add a second platform and test parallel execution
Replace the Manual Trigger with a Cron trigger
Connect Google Sheets to vary content daily
Add analytics webhooks to measure performance

If you're self-hosting, grab a VPS from Hetzner or Contabo, install n8n via Docker, and secure it with Nginx reverse proxy (I have a full guide on that setup). Then deploy this same workflow—it'll work identically.

Outsource Your Automation

Don't have time to configure this yourself? I build production n8n workflows, WhatsApp bots, and fully automated YouTube Shorts pipelines. Hire me on Fiverr—mention SYS3-DEVTO for priority. Or DM me at chasebot.online.

The beauty of automation is that you set it up once and it runs forever. Every hour you save is an hour you can spend on strategy, creative thinking, or just taking a break. That's the real win.

Originally published on Automation Insider.

How to Set Up Nginx Reverse Proxy with SSL (Let's Encrypt)

Raizan — Sat, 25 Apr 2026 08:00:26 +0000

What You'll Need

n8n Cloud or self-hosted n8n (optional, for API monitoring)
Hetzner VPS or Contabo VPS for your server
Namecheap for domain registration
DigitalOcean as an alternative hosting option
SSH access to your Linux server (Ubuntu 20.04 or later preferred)
A domain name pointing to your server's IP address
Basic command-line knowledge

Understanding Nginx Reverse Proxy Architecture
Installing Nginx and Certbot
Configuring Your First Reverse Proxy
Setting Up SSL with Let's Encrypt
Securing Your Configuration
Getting Started

Understanding Nginx Reverse Proxy Architecture

I've been managing production servers for years, and one thing I learned early: a reverse proxy is your infrastructure's best friend. Unlike a forward proxy (which shields clients), a reverse proxy sits between your internet-facing traffic and your internal applications. This setup gives you load balancing, SSL termination, security hardening, and the ability to run multiple services behind a single domain.

Here's why this matters: if you're running multiple backend services—say, a Node.js API on port 3000 and a Python Flask app on port 5000—a reverse proxy lets clients connect to both via api.example.com and app.example.com without exposing internal ports. Add Let's Encrypt SSL, and you've got enterprise-grade encryption for free.

This is especially useful if you're building automation workflows. For example, if you're running a self-hosted n8n Cloud instance or managing automation workflows that replace expensive SaaS tools, you'll want that traffic encrypted end-to-end.

Installing Nginx and Certbot

First, SSH into your server. I'm assuming you've already provisioned a Hetzner VPS or Contabo VPS with Ubuntu 20.04 or later. Your domain should already be pointing to your server's IP address (if not, update your DNS records at Namecheap).

Update your package manager and install Nginx:

sudo apt update
sudo apt upgrade -y
sudo apt install -y nginx

Start Nginx and enable it to run on boot:

sudo systemctl start nginx
sudo systemctl enable nginx

Check that Nginx is running:

sudo systemctl status nginx

You should see active (running) in the output. Now install Certbot, the Let's Encrypt client, and the Nginx plugin:

sudo apt install -y certbot python3-certbot-nginx

Verify the installation:

certbot --version

Great. Now we're ready to configure.

Configuring Your First Reverse Proxy

Let's say you have a backend service running on localhost:3000 (maybe a Node.js app, a Python service, or anything HTTP). You want to expose it securely at api.example.com.

Open the Nginx configuration directory:

sudo nano /etc/nginx/sites-available/default

Replace the entire file with this configuration:

upstream backend_service {
    server localhost:3000;
    keepalive 32;
}

server {
    listen 80;
    listen [::]:80;
    server_name api.example.com;

    location / {
        proxy_pass http://backend_service;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
        proxy_redirect off;
    }
}

Let me break this down:

upstream backend_service: Defines where traffic goes. Point this to your actual backend port.
listen 80: Listen on HTTP (Certbot will upgrade this to HTTPS).
server_name api.example.com: Your domain. Change this to your actual domain.
proxy_pass: Routes requests to your backend service.
proxy_set_header directives: Preserve client information (IP, protocol, domain) so your backend app sees the real client.

Test the configuration syntax:

sudo nginx -t

If you see syntax is ok, reload Nginx:

sudo systemctl reload nginx

If you visit http://api.example.com in your browser right now, it should proxy to your backend service on port 3000. The connection is unencrypted, though—that's next.

Setting Up SSL with Let's Encrypt

This is where the magic happens. Certbot automates the entire SSL setup, including renewal. Run Certbot with the Nginx plugin:

sudo certbot --nginx -d api.example.com

Certbot will ask a few questions:

Enter your email address (for renewal reminders).
Accept the Let's Encrypt terms of service.
Optionally share your email with the EFF (their choice).

Choose "2" when asked about redirecting HTTP to HTTPS:

Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: No redirect - Make no further changes to the webserver configuration.
2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for
new sites, unless you have a specific reason otherwise.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Certbot automatically modifies your Nginx config to enable HTTPS and redirect HTTP traffic. Here's what your config now looks like:

sudo cat /etc/nginx/sites-available/default

You'll see something like this (Certbot added the HTTPS server block and modified the HTTP block):

upstream backend_service {
    server localhost:3000;
    keepalive 32;
}

server {
    listen 80;
    listen [::]:80;
    server_name api.example.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name api.example.com;

    ssl_certificate /etc/letsencrypt/live/api.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/api.example.com/privkey.pem;

    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;

    location / {
        proxy_pass http://backend_service;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
        proxy_redirect off;
    }
}

Test the syntax:

sudo nginx -t

Reload Nginx:

sudo systemctl reload nginx

Now visit https://api.example.com. Your connection is encrypted with a valid SSL certificate—and it's completely free. Your certificate is valid for 90 days. Certbot automatically renews it before expiration via a system timer.

Verify the renewal timer is active:

sudo systemctl status certbot.timer

You should see active in the output.

Securing Your Configuration

A reverse proxy without proper security is like leaving your front door unlocked. Let's harden the setup.

1. Add Security Headers

Edit your Nginx config:

sudo nano /etc/nginx/sites-available/default

Add these directives inside the HTTPS server block (after ssl_dhparam):

add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;

These headers prevent clickjacking, MIME sniffing, and enforce HTTPS everywhere.

2. Limit Request Rate

If you're concerned about DDoS or brute-force attacks, add rate limiting. Insert this outside any server block (near the top of the file):

limit_req_zone $binary_remote_addr zone=general:10m rate=10r/s;
limit_req_zone $binary_remote_addr zone=login:10m rate=5r/m;

Then add this inside the HTTPS server block:

limit_req zone=general burst=20 nodelay;

3. Restrict File Access

Add this inside the HTTPS server block to block sensitive files:

location ~ /\. {
    deny all;
    access_log off;
    log_not_found off;
}

location ~ ~$ {
    deny all;
    access_log off;
    log_not_found off;
}

4. Enable Gzip Compression

Outside any server block, add:

gzip on;
gzip_vary on;
gzip_min_length 1000;
gzip_types text/plain text/css text/xml text/javascript application/json application/javascript application/xml+rss;
gzip_disable "MSIE [1-6]\.";

Test and reload:

sudo nginx -t
sudo systemctl reload nginx

Advanced: Multiple Backend Services

If you're running multiple services (say, an API and a web dashboard), create separate upstream blocks and location directives. Here's an example:

sudo nano /etc/nginx/sites-available/default

upstream api_backend {
    server localhost:3000;
    keepalive 32;
}

upstream app_backend {
    server localhost:5000;
    keepalive 32;
}

server {
    listen 80;
    listen [::]:80;
    server_name api.example.com app.example.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name api.example.com;

    ssl_certificate /etc/letsencrypt/live

Originally published on Automation Insider.

Jupiter API Guide: Free Solana Price Data for Your Apps

Raizan — Fri, 24 Apr 2026 08:00:28 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for self-hosting
DigitalOcean as an alternative hosting option
A Jupiter API key (free tier available)
Node.js 16+ or Python 3.8+ for local testing
Basic understanding of REST APIs and webhooks

Understanding Jupiter API and Why It Matters
Getting Your Free Jupiter API Key
Building Your First Price Data Query
Real-Time Solana Price Monitoring with n8n
Storing Price Data in Google Sheets
Advanced: Historical Data Analysis
Getting Started

Understanding Jupiter API and Why It Matters

I've been working with Solana ecosystem APIs for about three years now, and I can tell you that Jupiter API is one of the best-kept secrets for developers who need reliable, free Solana price data. Jupiter is the largest DEX aggregator on Solana, and their API exposes real-time pricing information that powers some of the most sophisticated trading bots and analytics platforms in the space.

What makes Jupiter different from other price APIs? Speed, accuracy, and zero rate limits for reasonable usage. You're not dealing with a centralized price feed—you're tapping directly into on-chain liquidity data from Solana's most liquid markets. This means you get true price discovery rather than some aggregated guess.

The use cases are endless: build portfolio dashboards, create alert systems when tokens hit certain prices, automate trading decisions, or feed price data into machine learning models. I've personally used Jupiter API to power everything from Discord bots that alert traders to automated portfolio rebalancers.

Getting Your Free Jupiter API Key

First, head to the Jupiter API documentation. They don't require traditional API keys—the API is public and free to use. This is one of the beauties of the Solana ecosystem. However, you'll want to understand rate limiting and best practices.

Here's the base endpoint you'll be working with:

https://price.jup.ag/v4/price

No authentication needed. Let me show you the anatomy of a real request:

curl -X GET "https://price.jup.ag/v4/price?ids=So11111111111111111111111111111111111111112&vsToken=EPjFWaJgt46ggsuKpQSetg69YXiGBkSstw2HYPi81md"

Breaking this down:

ids = the token mint address you want price data for (SOL in this case)
vsToken = what you're pricing against (USDC in this example)

The response looks like this:

{
  "data": {
    "So11111111111111111111111111111111111111112": {
      "id": "So11111111111111111111111111111111111111112",
      "type": "derivedPrice",
      "price": "175.50",
      "decimals": 2,
      "time": 1704067200000
    }
  },
  "timeTaken": 0.0001
}

Clean, fast, and immediately actionable. You get the price, decimal precision, and timestamp.

Building Your First Price Data Query

Let me walk you through a practical example. I'm going to show you how to query multiple tokens at once and parse the response in Node.js:

const https = require('https');

const tokenMints = {
  SOL: 'So11111111111111111111111111111111111111112',
  USDC: 'EPjFWaJgt46ggsuKpQSetg69YXiGBkSstw2HYPi81md',
  USDT: 'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenYes',
  RAY: '4k3Dyjzvzp8eMZWUXbBCjEvwSvsrH3xn5ZH3KD2Zcco',
  JUP: 'JUPyiwrYJFskUPiHa7hkeR8NqtwybKHLo3xKc4CMycJ'
};

const vsToken = 'EPjFWaJgt46ggsuKpQSetg69YXiGBkSstw2HYPi81md';

async function getPrices() {
  const mintIds = Object.values(tokenMints).join(',');
  const url = `https://price.jup.ag/v4/price?ids=${mintIds}&vsToken=${vsToken}`;

  return new Promise((resolve, reject) => {
    https.get(url, (res) => {
      let data = '';
      res.on('data', (chunk) => {
        data += chunk;
      });
      res.on('end', () => {
        try {
          const parsed = JSON.parse(data);
          resolve(parsed);
        } catch (e) {
          reject(e);
        }
      });
    }).on('error', (e) => {
      reject(e);
    });
  });
}

async function displayPrices() {
  try {
    const prices = await getPrices();
    const tokenNames = Object.keys(tokenMints);

    tokenNames.forEach((name, index) => {
      const mint = Object.values(tokenMints)[index];
      const priceData = prices.data[mint];
      if (priceData) {
        console.log(`${name}: $${priceData.price}`);
      }
    });
  } catch (error) {
    console.error('Error fetching prices:', error);
  }
}

displayPrices();

Save this as get-prices.js and run it:

node get-prices.js

You'll get output like:

SOL: $175.50
USDC: $1.00
USDT: $0.99
RAY: $1.25
JUP: $0.45

The beauty here is that you're making one request to get multiple token prices. This is efficient and respects Jupiter's infrastructure.

Real-Time Solana Price Monitoring with n8n

Now let's automate this. I'm going to show you how to build a workflow in n8n Cloud that queries Jupiter API every minute and stores results.

Here's your n8n workflow configuration (exportable JSON):

{
  "nodes": [
    {
      "parameters": {
        "rule": {
          "interval": [
            {
              "intervalValue": 1,
              "intervalUnit": "minutes"
            }
          ]
        }
      },
      "id": "fd5a4d6c-8c2e-4bbb-9f3e-2a1b3c4d5e6f",
      "name": "Trigger",
      "type": "n8n-nodes-base.cron",
      "typeVersion": 1,
      "position": [
        250,
        300
      ]
    },
    {
      "parameters": {
        "url": "https://price.jup.ag/v4/price",
        "options": {},
        "specialParameters": {
          "queryParameters": {
            "ids": "So11111111111111111111111111111111111111112,EPjFWaJgt46ggsuKpQSetg69YXiGBkSstw2HYPi81md,Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenYes",
            "vsToken": "EPjFWaJgt46ggsuKpQSetg69YXiGBkSstw2HYPi81md"
          }
        }
      },
      "id": "a1b2c3d4-e5f6-4g7h-8i9j-0k1l2m3n4o5p",
      "name": "Fetch Jupiter Prices",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.4,
      "position": [
        500,
        300
      ]
    },
    {
      "parameters": {
        "functionCode": "const data = $input.first().json.data;\nconst prices = {};\n\nconst tokenMap = {\n  'So11111111111111111111111111111111111111112': 'SOL',\n  'EPjFWaJgt46ggsuKpQSetg69YXiGBkSstw2HYPi81md': 'USDC',\n  'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenYes': 'USDT'\n};\n\nObject.keys(data).forEach(mint => {\n  const tokenName = tokenMap[mint];\n  if (tokenName) {\n    prices[tokenName] = {\n      price: data[mint].price,\n      timestamp: new Date(data[mint].time).toISOString()\n    };\n  }\n});\n\nreturn { prices, timestamp: new Date().toISOString() };"
      },
      "id": "b2c3d4e5-f6g7-4h8i-9j0k-1l2m3n4o5p6q",
      "name": "Transform Prices",
      "type": "n8n-nodes-base.function",
      "typeVersion": 1,
      "position": [
        750,
        300
      ]
    }
  ],
  "connections": {
    "Trigger": {
      "main": [
        [
          {
            "node": "Fetch Jupiter Prices",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Fetch Jupiter Prices": {
      "main": [
        [
          {
            "node": "Transform Prices",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}

After you create this workflow in n8n, you can extend it by adding a webhook that triggers alerts when prices move by more than 5%. Here's the alert logic you'd add to the Transform Prices function:

const data = $input.first().json.data;
const prices = {};
const tokenMap = {
  'So11111111111111111111111111111111111111112': 'SOL',
  'EPjFWaJgt46ggsuKpQSetg69YXiGBkSstw2HYPi81md': 'USDC',
  'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenYes': 'USDT'
};

const previousPrices = {
  SOL: 175.00,
  USDC: 1.00,
  USDT: 0.99
};

Object.keys(data).forEach(mint => {
  const tokenName = tokenMap[mint];
  if (tokenName) {
    const currentPrice = parseFloat(data[mint].price);
    const previousPrice = previousPrices[tokenName];

Originally published on Automation Insider.

Building a Lead Capture System with n8n and Typeform

Raizan — Thu, 23 Apr 2026 08:00:28 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for self-hosting
Namecheap if you need a custom domain
Typeform account (free tier works)
A spreadsheet tool like Google Sheets or Airtable (optional but recommended)

Why Typeform + n8n Is a Game-Changer
Setting Up Your Typeform
Connecting n8n to Typeform
Building the Lead Capture Workflow
Adding Data Validation and Filtering
Storing Leads in Google Sheets
Sending Automated Follow-Up Emails
Testing and Deploying
Getting Started

Why Typeform + n8n Is a Game-Changer

I've been building automation workflows for three years now, and the combination of Typeform and n8n Cloud is hands-down one of the most cost-effective ways to capture, validate, and nurture leads without touching a single line of code—well, almost.

Here's the reality: most teams either pay $50–200/month for marketing automation platforms that feel bloated, or they cobble together Zapier, Make.com, and custom scripts that break after every update. With n8n, you own your workflow completely. No surprise pricing. No feature limits based on your plan tier.

When a lead fills out your Typeform, n8n instantly captures that data, validates it, stores it wherever you want, and triggers follow-up actions—all in a single, unified workflow. If you're already looking to optimize your stack, check out our guide on 5 n8n Workflows That Replace $200/Month in SaaS Tools to see how many other platforms you can retire.

Setting Up Your Typeform

First, let's create the form that'll capture your leads. I'm going to keep it simple for this guide—name, email, phone, and a company field.

Log into Typeform and click Create a new form. Choose the Blank template. Here's what to add:

Field 1: Full Name

Question type: Short text
Question: "What's your full name?"
Make it required

Field 2: Email Address

Question type: Email
Question: "What's your email address?"
Make it required

Field 3: Phone Number

Question type: Phone number
Question: "What's your phone number?"
Optional

Field 4: Company

Question type: Short text
Question: "What company are you with?"
Optional

Field 5: How did you hear about us?

Question type: Multiple choice
Options: Google, LinkedIn, Referral, Other
Make it required

Once you've built the form, click Share and grab the public link. You'll also need your Typeform API token, which you can get from your account settings under API & Apps → Personal tokens. Create a new token and copy it—you'll need this in n8n.

Connecting n8n to Typeform

Now let's set up n8n Cloud to listen for new Typeform responses. If you're self-hosting, the steps are identical—just deploy n8n on a Hetzner VPS or Contabo VPS first.

Log into n8n and create a new workflow. Start by dragging in a Webhook node—this is how n8n will receive data from Typeform in real-time.

In the Webhook node:

Set HTTP Method to POST
Copy the webhook URL (you'll need this in Typeform)
Leave Authentication as None for now (we'll secure it later if needed)

Now, head back to Typeform. Go to your form's Settings → Integrations → Webhooks. Paste your n8n webhook URL and select which events to trigger on—choose Response completed.

Next, add a Typeform node in n8n to pull historical responses. Click the + icon to add a new node, search for Typeform, and select the Typeform trigger node.

Create a new Typeform credential:

Paste your API token
Test the connection

Select your form from the dropdown. This node will trigger whenever a new response is submitted.

Building the Lead Capture Workflow

Here's the actual workflow we're going to build. I'll walk you through each node.

Node 1: Typeform Trigger
This is your entry point. It fires whenever someone submits the form.

Node 2: Parse the Response
Add a Set node to extract and structure the data:

{
  "full_name": "{{ $json.form_response.answers[0].text }}",
  "email": "{{ $json.form_response.answers[1].email }}",
  "phone": "{{ $json.form_response.answers[2].phone_number }}",
  "company": "{{ $json.form_response.answers[3].text }}",
  "source": "{{ $json.form_response.answers[4].choice.label }}",
  "submission_id": "{{ $json.form_response.token }}",
  "submitted_at": "{{ $json.form_response.submitted_at }}"
}

This restructures the Typeform response into clean, usable data.

Adding Data Validation and Filtering

Not every submission is a qualified lead. Let's add validation to filter out bad data.

Add an If node after your Set node:

// Check if email exists and is valid
$json.email && $json.email.includes('@')
// AND check if name is at least 2 characters
&& $json.full_name && $json.full_name.length >= 2

If the condition is true, the workflow continues. If false, it stops—you can optionally send a data quality error notification.

For additional filtering, you might want to check against your existing customer database. Use another If node to query a database and mark duplicates:

// Example: Skip if email already in database
!$json.existing_customer

When you're building more complex workflows like this, exploring The Best Free APIs for Building Automation Workflows in 2026 can help you integrate additional validation services without cost.

Storing Leads in Google Sheets

Now let's save every valid lead to a spreadsheet. Add a Google Sheets node.

Set up your Google credentials:

Click Authenticate
Select your Google account
Choose or create a new spreadsheet

In the Google Sheets node:

Document ID: Paste your spreadsheet ID (from the URL)
Sheet: Select the sheet name (e.g., "Leads")
Columns: Map each field:

Column A: full_name → {{ $json.full_name }}
Column B: email → {{ $json.email }}
Column C: phone → {{ $json.phone }}
Column D: company → {{ $json.company }}
Column E: source → {{ $json.source }}
Column F: submitted_at → {{ $json.submitted_at }}

This creates a permanent record of every lead your form captures.

Sending Automated Follow-Up Emails

The real power of this system is automation. Let's send a personalized welcome email the moment someone becomes a lead.

Add a Send Email node (or use Gmail if you want to send from your Gmail account):

Configure it like this:

To: {{ $json.email }}
From: noreply@yourcompany.com
Subject: Welcome, {{ $json.full_name }}! Here's what's next

For the email body, use HTML:

<h2>Hey {{ $json.full_name }},</h2>

<p>Thanks for filling out our form! We saw you're with <strong>{{ $json.company }}</strong> and heard about us through <strong>{{ $json.source }}</strong>.</p>

<p>Here's what happens next:</p>
<ul>
  <li>Our team will review your information</li>
  <li>You'll get a personalized demo within 24 hours</li>
  <li>We'll answer any questions you have</li>
</ul>

<p>In the meantime, <a href="https://yourcompany.com/resources">check out our resources</a>.</p>

<p>Cheers,<br/>The Team</p>

If you want to take this further and automate email sequences, our guide on Automate Your Email Newsletter with n8n and Claude shows how to generate personalized content at scale using AI.

Testing and Deploying

Before you go live, test the entire workflow. Click Execute Workflow and fill out your Typeform manually. Watch each node execute in real-time:

The Typeform trigger fires
Data is parsed and structured
Validation checks pass
Lead is added to Google Sheets
Welcome email is sent

If any step fails, n8n will show you the exact error. Common issues:

Invalid email format → Typeform should validate this, but n8n double-checks
Google Sheets authentication expired → Re-authenticate
Email sending fails → Check your email provider's SMTP credentials

Once everything works, click Activate to turn on the workflow. It's now live and listening for new Typeform submissions 24/7.

Getting Started

You're ready to capture leads like a pro. Here's your checklist:

Create your Typeform with the fields you need
Set up n8n Cloud (or self-host on Hetzner VPS)
Connect Typeform's API to n8n
Build the workflow following the steps above
Test thoroughly before activating
Monitor your Google Sheets for leads rolling in

From here, you can expand: add Slack notifications, integrate with your CRM, score leads based on company size, or trigger different workflows based on which "source" they selected.

Outsource Your Automation

Don't have time? I build production n8n workflows, WhatsApp bots, and fully automated YouTube Shorts pipelines. Hire me on Fiverr — mention SYS3-DEVTO for priority. Or DM at chasebot.online.

Originally published on Automation Insider.

How to Deploy n8n with Docker on Any VPS (2026 Guide)

Raizan — Wed, 22 Apr 2026 08:00:22 +0000

What You'll Need

n8n Cloud or self-hosted n8n (we're covering self-hosted)
Hetzner VPS, Contabo VPS, or DigitalOcean
A domain name (optional, but recommended—grab one at Namecheap)
Basic command-line comfort
2GB+ RAM and 20GB+ storage on your VPS

Why Self-Host n8n on a VPS?
Setting Up Your VPS
Installing Docker
Deploying n8n with Docker Compose
Configuring SSL and Your Domain
Running Your First Workflow
Getting Started with Production

Why Self-Host n8n on a VPS?

I made the switch to self-hosted n8n about two years ago, and honestly, it changed how I build automation. You get complete control over your workflows, no per-execution pricing limits, and the ability to run custom code without restrictions. Plus, if you're already paying for a VPS for automation, you can run n8n alongside other services—databases, APIs, webhooks—all in one place.

The deployment is surprisingly straightforward with Docker. I'll walk you through it step-by-step so you can have a production-ready n8n instance running in under an hour.

Setting Up Your VPS

Start with a fresh Ubuntu 22.04 LTS instance. If you're comparing hosting options, I've got a detailed breakdown of VPS choices for automation (Hetzner vs Contabo vs Railway) that might help you decide. For this guide, I'm assuming you've already provisioned your server and can SSH into it.

Connect to your VPS:

ssh root@your_vps_ip_address

Update your system packages:

apt update && apt upgrade -y

Create a non-root user for security (optional but recommended):

adduser n8nuser
usermod -aG sudo n8nuser
su - n8nuser

Installing Docker

Docker is the easiest way to run n8n without dependency hell. Install the official Docker repository:

sudo apt install -y ca-certificates curl gnupg lsb-release
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Install Docker and Docker Compose:

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

Verify the installation:

docker --version
docker compose version

Add your user to the Docker group so you don't need sudo every time:

sudo usermod -aG docker $USER
newgrp docker

Deploying n8n with Docker Compose

Create a project directory:

mkdir -p ~/n8n-deployment
cd ~/n8n-deployment

Create a .env file for configuration:

cat > .env << 'EOF'
N8N_HOST=your-domain.com
N8N_PORT=5678
N8N_PROTOCOL=https
NODE_ENV=production
N8N_SECURE_COOKIE=true
N8N_ENCRYPTION_KEY=$(openssl rand -hex 32)
GENERIC_TIMEZONE=UTC
DB_TYPE=postgres
DB_POSTGRESDB_HOST=postgres
DB_POSTGRESDB_PORT=5432
DB_POSTGRESDB_DATABASE=n8n
DB_POSTGRESDB_USER=n8n
DB_POSTGRESDB_PASSWORD=$(openssl rand -hex 16)
WEBHOOK_URL=https://your-domain.com/webhook
EOF

Replace your-domain.com with your actual domain. If you don't have a domain yet, grab one from Namecheap for cheap.

Now create the docker-compose.yml file:

cat > docker-compose.yml << 'EOF'
version: '3.8'

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

  n8n:
    image: n8nio/n8n:latest
    container_name: n8n-app
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - DB_TYPE=${DB_TYPE}
      - DB_POSTGRESDB_HOST=${DB_POSTGRESDB_HOST}
      - DB_POSTGRESDB_PORT=${DB_POSTGRESDB_PORT}
      - DB_POSTGRESDB_DATABASE=${DB_POSTGRESDB_DATABASE}
      - DB_POSTGRESDB_USER=${DB_POSTGRESDB_USER}
      - DB_POSTGRESDB_PASSWORD=${DB_POSTGRESDB_PASSWORD}
      - N8N_HOST=${N8N_HOST}
      - N8N_PORT=${N8N_PORT}
      - N8N_PROTOCOL=${N8N_PROTOCOL}
      - NODE_ENV=${NODE_ENV}
      - N8N_SECURE_COOKIE=${N8N_SECURE_COOKIE}
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      - GENERIC_TIMEZONE=${GENERIC_TIMEZONE}
      - WEBHOOK_URL=${WEBHOOK_URL}
    volumes:
      - n8n_data:/home/node/.n8n
    networks:
      - n8n-net
    depends_on:
      postgres:
        condition: service_healthy

  nginx:
    image: nginx:alpine
    container_name: n8n-nginx
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./ssl:/etc/nginx/ssl:ro
    networks:
      - n8n-net
    depends_on:
      - n8n

volumes:
  postgres_data:
  n8n_data:

networks:
  n8n-net:
    driver: bridge
EOF

Create the Nginx configuration file:

cat > nginx.conf << 'EOF'
user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log warn;
pid /var/run/nginx.pid;

events {
    worker_connections 1024;
}

http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;

    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" '
                    '"$http_user_agent" "$http_x_forwarded_for"';

    access_log /var/log/nginx/access.log main;

    sendfile on;
    tcp_nopush on;
    keepalive_timeout 65;
    types_hash_max_size 2048;
    gzip on;

    upstream n8n {
        server n8n:5678;
    }

    server {
        listen 80;
        server_name your-domain.com;
        return 301 https://$server_name$request_uri;
    }

    server {
        listen 443 ssl http2;
        server_name your-domain.com;

        ssl_certificate /etc/nginx/ssl/cert.pem;
        ssl_certificate_key /etc/nginx/ssl/key.pem;
        ssl_protocols TLSv1.2 TLSv1.3;
        ssl_ciphers HIGH:!aNULL:!MD5;
        ssl_prefer_server_ciphers on;

        client_max_body_size 50M;

        location / {
            proxy_pass http://n8n;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection 'upgrade';
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_cache_bypass $http_upgrade;
        }
    }
}
EOF

Configuring SSL and Your Domain

First, point your domain to your VPS IP address in your DNS provider. Create an SSL certificate using Let's Encrypt:

sudo apt install -y certbot python3-certbot-nginx
sudo mkdir -p ssl
cd ssl
sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout key.pem -out cert.pem -subj "/CN=your-domain.com"
cd ..

For production, use Let's Encrypt instead:

sudo certbot certonly --standalone -d your-domain.com --non-interactive --agree-tos -m your-email@example.com
sudo cp /etc/letsencrypt/live/your-domain.com/fullchain.pem ssl/cert.pem
sudo cp /etc/letsencrypt/live/your-domain.com/privkey.pem ssl/key.pem
sudo chown -R $USER:$USER ssl/

Update your nginx.conf with your actual domain name (replace your-domain.com twice in the file).

Start the deployment:

docker compose up -d

Check that all containers are running:

docker compose ps

You should see three services: n8n-postgres, n8n-app, and n8n-nginx. View logs if anything fails:

docker compose logs -f n8n-app

Running Your First Workflow

Open your browser and go to https://your-domain.com. You'll see the n8n setup screen. Create your admin account and log in.

Once inside, create a simple test workflow to verify everything works. Click the + button to add a trigger node. Select Webhook:

{
  "method": "POST",
  "path": "webhook/test"
}

Add an HTTP Request node:

Originally published on Automation Insider.

ffmpeg for Content Creators: Essential Commands Cheat Sheet

Raizan — Tue, 21 Apr 2026 08:00:28 +0000

What You'll Need

A computer with FFmpeg installed (Windows, Mac, or Linux)
Hetzner VPS or Contabo VPS if you're encoding videos at scale
DigitalOcean as an alternative cloud option
Basic command-line comfort
Sample media files (video or audio) to practice with

Why FFmpeg Matters for Content Creators
Video Conversion & Compression
Audio Extraction & Processing
Batch Processing Multiple Files
Creating Animated GIFs & Thumbnails
Advanced Streaming & Watermarking
Getting Started

Why FFmpeg Matters for Content Creators

I've been automating content workflows for years, and FFmpeg is the backbone of almost every video pipeline I build. It's free, it's powerful, and it runs on literally any server. If you're producing YouTube videos, Shorts, TikToks, or streaming content, you need to understand at least the basics.

The problem? FFmpeg has a reputation for being intimidating. The command syntax looks like ancient incantations. But once you learn the structure, you'll realize it's just a series of logical parameters: input → filters → codec → output.

When I automate video processing at scale, I often use n8n Cloud to orchestrate FFmpeg jobs across multiple files. If you're looking to build a fully automated content production system, understanding FFmpeg pairs perfectly with workflow automation tools.

Let me give you the commands you'll actually use every single day.

Video Conversion & Compression

Basic MP4 Conversion

This is the most common task. You've got a video file in some weird format, and you need it as MP4 for YouTube or web delivery.

ffmpeg -i input.mov -c:v libx264 -preset fast -crf 23 -c:a aac -b:a 192k output.mp4

Breaking this down:

-i input.mov — your input file
-c:v libx264 — use H.264 video codec (compatible everywhere)
-preset fast — encoding speed (fast, medium, slow; slower = better quality/bigger file)
-crf 23 — quality (0-51; lower is better, 18-28 is typical)
-c:a aac — audio codec
-b:a 192k — audio bitrate
output.mp4 — destination

4K to 1080p Downscaling

YouTube creators often need multiple resolutions. Here's how to downscale 4K to 1080p while maintaining quality:

ffmpeg -i input_4k.mp4 -vf scale=1920:1080 -c:v libx264 -preset medium -crf 21 -c:a aac -b:a 192k output_1080p.mp4

The -vf scale=1920:1080 filter resizes while maintaining aspect ratio.

Highly Compressed Version for Mobile

For social media where file size matters:

ffmpeg -i input.mp4 -c:v libx264 -preset fast -crf 28 -s 1280x720 -c:a aac -b:a 128k output_mobile.mp4

The -s 1280x720 flag sets resolution explicitly.

WebM for Web Delivery

WebM files are smaller than MP4 and great for embedding in websites:

ffmpeg -i input.mp4 -c:v libvpx-vp9 -b:v 1000k -c:a libopus -b:a 128k output.webm

VP9 takes longer to encode but creates tiny, high-quality files.

Audio Extraction & Processing

Extract Audio as MP3

You have a video but only need the audio—common for podcasts or music content:

ffmpeg -i input.mp4 -q:a 0 -map a output.mp3

The -q:a 0 flag extracts the highest quality audio.

Extract Audio as WAV (Lossless)

For professional audio work or archival:

ffmpeg -i input.mp4 -c:a pcm_s16le output.wav

Compress Audio Only

Reduce file size without re-encoding video. This is useful when you're working with existing MP4s:

ffmpeg -i input.mp4 -c:v copy -c:a libmp3lame -b:a 128k output.mp4

The -c:v copy flag skips video re-encoding entirely—instant processing.

Add Audio Track to Video (Without Audio)

You've got a silent video and a separate audio file:

ffmpeg -i video_silent.mp4 -i audio.mp3 -c:v copy -c:a aac -map 0:v:0 -map 1:a:0 output.mp4

This maps the video from file 0 and audio from file 1.

Normalize Audio Loudness

If your audio is too quiet or too loud:

ffmpeg -i input.mp4 -af loudnorm=I=-16:TP=-1.5:LRA=11 -c:v copy output.mp4

The loudnorm filter adjusts to broadcast standard loudness.

Batch Processing Multiple Files

Here's where FFmpeg becomes truly powerful. Let's say you have 50 videos that need conversion.

Bash Script for Batch Conversion (Linux/Mac)

#!/bin/bash
for file in *.mov; do
  output="${file%.mov}.mp4"
  ffmpeg -i "$file" -c:v libx264 -preset fast -crf 23 -c:a aac -b:a 192k "$output"
done

Save this as convert_all.sh, then run chmod +x convert_all.sh && ./convert_all.sh.

Windows Batch Script

@echo off
for %%f in (*.mov) do (
  ffmpeg -i "%%f" -c:v libx264 -preset fast -crf 23 -c:a aac -b:a 192k "%%~nf.mp4"
)
pause

Save as convert_all.bat and double-click.

Parallel Processing on a VPS

If you're running this on a Hetzner VPS with multiple CPU cores, use GNU Parallel:

find . -name "*.mov" | parallel ffmpeg -i {} -c:v libx264 -preset fast -crf 23 -c:a aac -b:a 192k {.}.mp4

This processes multiple files simultaneously, cutting your total time dramatically.

For automated batch processing at enterprise scale, I'd recommend integrating FFmpeg with n8n Cloud to trigger conversions based on file uploads or events. This is especially useful if you're running a system to monitor your VPS with n8n health check workflows since you can automatically alert when encoding finishes.

Creating Animated GIFs & Thumbnails

Convert Video to Animated GIF

Perfect for social media previews:

ffmpeg -i input.mp4 -vf "fps=10,scale=320:-1:flags=lanczos" -c:v gif output.gif

fps=10 — 10 frames per second (lower = smaller file)
scale=320:-1 — scale to 320px wide, maintain aspect ratio
flags=lanczos — high-quality scaling algorithm

Extract a Single Frame as Thumbnail

Get a frame at exactly 15 seconds in:

ffmpeg -ss 00:00:15 -i input.mp4 -vf scale=1280:720 -q:v 2 thumbnail.jpg

The -ss 00:00:15 flag seeks to 15 seconds. Adjust timing to capture your best moment.

Extract Multiple Frames

Create a grid of thumbnails from your video:

ffmpeg -i input.mp4 -vf "fps=1/10,scale=320:240" -q:v 2 frame_%04d.jpg

This extracts one frame every 10 seconds. Perfect for creating preview grids.

High-Quality Thumbnail

YouTube-optimized thumbnail (1280x720):

ffmpeg -ss 00:00:30 -i input.mp4 -vf scale=1280:720 -q:v 1 -frames:v 1 thumbnail_hq.jpg

Advanced Streaming & Watermarking

Add a Text Watermark

Overlay text on your video (useful for branding):

ffmpeg -i input.mp4 -vf "drawtext=text='YourName':fontfile=/path/to/font.ttf:fontsize=24:fontcolor=white:x=10:y=10" -c:v libx264 -preset fast output.mp4

On Mac, use /Library/Fonts/Arial.ttf. On Linux, try /usr/share/fonts/truetype/dejavu/DejaVuSans.ttf.

Add an Image Watermark

Overlay a logo or watermark image:

ffmpeg -i input.mp4 -i logo.png -filter_complex "[0:v][1:v] overlay=W-w-10:H-h-10:enable='between(t,0,duration)'" -c:v libx264 -preset fast output.mp4

This places the logo 10px from the bottom-right corner.

Create DASH Streaming Files

For adaptive bitrate streaming (HLS/DASH):

ffmpeg -i input.mp4 -c:v libx264 -s 1920x1080 -b:v 5000k -c:a aac -b:a 192k stream_1080p.mp4 -c:v libx264 -s 1280x720 -b:v 2500k -c:a aac -b:a 128k stream_720p.mp4 -c:v libx264 -s 854x480 -b:v 1000k -c:a aac -b:a 96k stream_480p.mp4

This creates three quality tiers from a single source—essential for professional streaming.

Segment Video into Chunks

Break a long video into smaller files (useful for uploading or processing):

ffmpeg -i input.mp4 -c copy -segment_time 00:05:00 -f segment segment_%03d.mp4

This creates 5-minute chunks: segment_000.mp4, segment_001.mp4, etc.

Getting Started

Installation:

Mac: brew install ffmpeg
Linux (Ubuntu/Debian): sudo apt-get install ffmpeg
Windows: Download from ffmpeg.org or use choco install ffmpeg if you have Chocolatey

Hosting your FFmpeg jobs:

If you're encoding at scale, rent a Hetzner VPS (CPU-optimized instance) or Contabo VPS with multiple cores. A single good server can encode 10+ videos simultaneously.

Automating FFmpeg:

The real power emerges when you integrate FFmpeg into your workflows. If you're

Originally published on Automation Insider.

Automate Your Email Newsletter with n8n and Claude

Raizan — Mon, 20 Apr 2026 08:00:29 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for self-hosting
Claude API key from Anthropic
Gmail or SMTP credentials for sending
A list of subscriber emails (spreadsheet or database)

Why Automate Your Newsletter?
Building the Core Workflow
Integrating Claude for Content Generation
Setting Up Email Distribution
Testing and Scheduling
Getting Started

Why Automate Your Newsletter?

I've been running newsletters for three years now, and I can tell you: doing it manually kills momentum. Every week you're drafting, editing, formatting, and manually sending to your list. By week four, you've burned out. By month two, your subscribers are getting ghosted.

Automation changed everything for me. Instead of spending 4-5 hours per week on my newsletter, I now spend 30 minutes setting up a workflow that does the heavy lifting. n8n handles the scheduling, Claude generates smart content based on my topic prompts, and your email provider sends it out to thousands of people.

The workflow I'm sharing with you today can:

Generate newsletter content automatically using Claude's API
Pull subscriber lists from Google Sheets or a database
Send personalized emails at scale
Log analytics so you know what worked
Run on a schedule you define (weekly, daily, monthly—whatever)

Let's build it.

Building the Core Workflow

Open n8n Cloud and create a new workflow. I'm calling mine "AI Newsletter Generator."

The workflow structure is simple:

Trigger – A schedule node fires weekly
Generate Content – Claude API creates the newsletter body
Fetch Subscribers – Pull your email list
Send Emails – Distribute to each subscriber
Log Results – Track success/failures

Let's start with the schedule trigger.

Step 1: Add a Schedule Trigger

In n8n, click + and search for "Schedule Trigger." Configure it:

{
  "mode": "Every Week",
  "dayOfWeek": "Monday",
  "time": "09:00"
}

This fires every Monday at 9 AM. Adjust to your preference.

Step 2: Claude API Node

Add a new node and search for HTTP Request (we'll use it to call Claude's API directly since n8n doesn't have a native Claude node yet).

Configure the HTTP node:

{
  "method": "POST",
  "url": "https://api.anthropic.com/v1/messages",
  "authentication": "Generic Credential Type",
  "sendHeaders": true,
  "headerParameters": {
    "x-api-key": "YOUR_CLAUDE_API_KEY",
    "anthropic-version": "2023-06-01",
    "content-type": "application/json"
  },
  "sendBody": true,
  "bodyParameters": {
    "model": "claude-3-5-sonnet-20241022",
    "max_tokens": 1024,
    "system": "You are a professional newsletter writer. Create engaging, concise newsletter content based on the topic provided. Format with a catchy subject line, brief intro paragraph, 3 main points with explanations, and a call-to-action.",
    "messages": [
      {
        "role": "user",
        "content": "Write a newsletter about the latest trends in workflow automation and AI integration. Keep it under 300 words."
      }
    ]
  }
}

The key fields:

model: Claude 3.5 Sonnet is fast and cheap for this use case
max_tokens: 1024 gives you about 750 words
system: This prompt tells Claude how to format the newsletter
messages: Your actual newsletter topic

The response will look like:

{
  "id": "msg_123456",
  "type": "message",
  "content": [
    {
      "type": "text",
      "text": "Subject: Your Weekly Automation Digest\n\nHi there!..."
    }
  ]
}

We'll extract the content[0].text in the next step.

Integrating Claude for Content Generation

Step 3: Parse Claude Response

Add a Set Node to extract and format the Claude output:

{
  "data": {
    "newsletterContent": "{{ $nodes['HTTP Request'].data.body.content[0].text }}",
    "generatedAt": "{{ now.toIso() }}",
    "status": "generated"
  }
}

This pulls the text Claude generated and adds metadata.

Step 4: Split Subject and Body

Claude will return a formatted newsletter with a subject line, but we need to split them. Add another Function Node:

const content = items[0].json.data.newsletterContent;
const lines = content.split('\n');
let subject = '';
let body = '';

const subjectIndex = lines.findIndex(line => line.startsWith('Subject:'));
if (subjectIndex !== -1) {
  subject = lines[subjectIndex].replace('Subject:', '').trim();
  body = lines.slice(subjectIndex + 2).join('\n');
} else {
  subject = 'Your Weekly Newsletter';
  body = content;
}

return [{
  json: {
    subject: subject,
    body: body,
    generatedAt: new Date().toISOString()
  }
}];

Now we have a clean subject and body ready to email.

Setting Up Email Distribution

Step 5: Fetch Subscriber List

This is where many people use Google Sheets as a free database. If you haven't already, check out how to use Google Sheets as a free database with n8n for more details.

Add a Google Sheets node:

{
  "operation": "Get All Rows",
  "spreadsheetId": "YOUR_SHEET_ID",
  "sheetName": "subscribers",
  "options": {
    "headerRow": 1
  }
}

Your sheet should have columns: email, name, status. Filter for status = active to avoid sending to unsubscribed users.

Step 6: Loop and Send Emails

Add a Loop node to iterate through each subscriber. Inside the loop, add an SMTP Email node (or Gmail, depending on your preference):

{
  "method": "SMTP",
  "fromEmail": "your-email@yourcompany.com",
  "fromName": "Your Newsletter",
  "toEmail": "{{ $item.json.email }}",
  "subject": "{{ $nodes['Set'].data.subject }}",
  "textMimeType": "text/html",
  "htmlBody": "<html><body><h2>{{ $item.json.name }}, here's this week's update:</h2><p>{{ $nodes['Set'].data.body }}</p><p><a href='https://yourcompany.com/unsubscribe?email={{ $item.json.email }}'>Unsubscribe</a></p></body></html>",
  "smtpCredentials": "YOUR_SMTP_CREDENTIAL"
}

Key points:

Use $item.json.email to address each subscriber
Personalize with $item.json.name
Include an unsubscribe link (legal requirement under CAN-SPAM)
Use HTML for better formatting

Step 7: Error Handling

Add an Error Handler node to catch failed sends:

{
  "operation": "Continue",
  "onError": true,
  "errorOutput": {
    "email": "{{ $item.json.email }}",
    "error": "{{ $error.message }}",
    "timestamp": "{{ now.toIso() }}"
  }
}

This logs failures without stopping the entire workflow.

Testing and Scheduling

Step 8: Test with One Subscriber

Before going live, test with yourself. Modify your Google Sheet to have just one test email. Click Execute in n8n and check your inbox.

Look for:

✅ Subject line is correct
✅ Body formatting is clean
✅ Links work
✅ No HTML escaping issues

If Claude generates weird formatting, adjust the system prompt. Example:

"system": "You are a professional newsletter writer. Output ONLY HTML. Start with <h1>Subject: [subject]</h1>. Do not include markdown or asterisks."

Step 9: Production Scheduling

Once you're confident, update the Schedule Trigger to your real frequency:

{
  "mode": "Every Week",
  "dayOfWeek": "Monday",
  "time": "09:00",
  "timezone": "America/New_York"
}

n8n will run this automatically every Monday at 9 AM.

Step 10: Add Analytics (Optional but Recommended)

Create a second Google Sheet called "newsletter_logs" and add a Google Sheets node at the end of your workflow:

{
  "operation": "Append",
  "spreadsheetId": "YOUR_SHEET_ID",
  "sheetName": "newsletter_logs",
  "data": {
    "date_sent": "{{ now.toIso() }}",
    "subject": "{{ $nodes['Set'].data.subject }}",
    "recipients_count": "{{ $nodes['Loop'].data.length }}",
    "failed_count": "{{ $nodes['Error Handler'].data.length }}",
    "status": "completed"
  }
}

This tracks every send so you can spot patterns (e.g., "Mondays at 9 AM get better open rates").

Getting Started

You're ready to launch. Here's your checklist:

Get n8n: Sign up for n8n Cloud or self-host on Hetzner / Contabo
Set up Claude API: Get your key from Anthropic (free tier gives you $5 credit)
Prepare your subscriber list: Upload to Google Sheets with email and name columns
Build the workflow: Follow the steps above
Test: Send one email to yourself
Deploy: Set the schedule and let it run

A few advanced tweaks you might consider:

Add the best free APIs for building automation workflows to your newsletter—pull trending tech news and include it in your Claude prompt
Use Zapier or Make.com for simple integrations, but n8n is more powerful and costs less at scale
If you want to add audio versions, check out Edge TTS for free text-to-speech

Outsource Your Automation

Don't have time? I build production n8n workflows, WhatsApp bots, and fully automated YouTube Shorts pipelines. Hire me on Fiverr — mention SYS3-DEVTO for priority. Or DM at chasebot.online.

Originally published on Automation Insider.

How to Use Google Sheets as a Free Database with n8n

Raizan — Sun, 19 Apr 2026 08:00:28 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for self-hosting
A Google account with Google Sheets access
Basic familiarity with n8n (optional—I'll walk you through it)

Why Google Sheets as a Database?
Setting Up Google Sheets Credentials in n8n
Building Your First Read Workflow
Writing Data to Sheets
Advanced: Multi-Sheet Workflows and Error Handling
Getting Started

Why Google Sheets as a Database?

I started using Google Sheets as a database when I was bootstrapping projects and couldn't justify $50/month for a traditional database. Honestly? It works incredibly well for small to medium workflows.

Here's why I love it:

Free and unlimited rows. Google Sheets gives you enough space for thousands of records without paying a cent.

Built-in collaboration. Multiple team members can view and comment on data in real-time.

Easy backups. Google handles versioning automatically.

Zero setup. No Docker containers, no PostgreSQL configuration, no DevOps headaches.

Native n8n integration. The Google Sheets node in n8n is rock-solid and handles authentication seamlessly.

The downside? It's slower than a true database at scale (10,000+ rows), but for workflows under 5,000 records, you won't notice a difference. I've actually built workflows that replace $200/month in SaaS tools using nothing but Google Sheets and n8n.

Setting Up Google Sheets Credentials in n8n

Before you write a single workflow, you need to authenticate Google Sheets in n8n Cloud.

Step 1: Create a new workflow in n8n

Log into your n8n account and click "New Workflow."

Step 2: Add a Google Sheets node

Search for "Google Sheets" in the node panel and drag it onto your canvas.

Step 3: Authenticate with Google

Click the "Authenticate" button (the credential field). A popup will appear asking for permission. Sign in with your Google account and authorize n8n to access your Google Sheets.

Here's what the credential connection looks like in the node configuration:

{
  "authentication": "oAuth2",
  "client_id": "YOUR_GOOGLE_CLIENT_ID",
  "client_secret": "YOUR_GOOGLE_CLIENT_SECRET",
  "redirect_uri": "https://n8n.yourinstance.com/oauth-callback"
}

If you're self-hosting n8n on a Hetzner VPS or DigitalOcean, you'll need to set up OAuth credentials in the Google Cloud Console:

Go to console.cloud.google.com
Create a new project called "n8n Workflows"
Enable the Google Sheets API and Google Drive API
Create an OAuth 2.0 credential (Application type: Web application)
Set authorized redirect URI to https://your-n8n-domain.com/oauth-callback
Copy the Client ID and Secret into n8n

That's it. You're ready to read and write data.

Building Your First Read Workflow

Let me show you how to read data from a Google Sheet. I'm assuming you have a spreadsheet already created—if not, create one and add some test data.

The setup:

Sheet name: Contacts
Columns: Name, Email, Phone, Status

Here's a simple workflow that reads all rows:

Step 1: Add a Google Sheets node set to "Read"

In the node configuration:

Operation: Read
Spreadsheet: Select your spreadsheet from the dropdown
Sheet: Contacts
Read from: A1 (top-left corner)
First Row as Headers: Yes

Step 2: Add a function node to transform the data

This optional node cleans up the response and makes it easier to work with:

return $input.all().map(item => {
  return {
    name: item.json.Name,
    email: item.json.Email,
    phone: item.json.Phone,
    status: item.json.Status
  };
});

Step 3: Test and execute

Click "Execute" and you'll see the data returned as a JSON array. Each row from your sheet becomes an object:

[
  {
    "name": "Alice Johnson",
    "email": "alice@example.com",
    "phone": "555-0101",
    "status": "Active"
  },
  {
    "name": "Bob Smith",
    "email": "bob@example.com",
    "phone": "555-0102",
    "status": "Inactive"
  }
]

That's it. You're now reading from Google Sheets inside n8n.

Writing Data to Sheets

Reading is half the battle. Here's how to write new records back to your spreadsheet.

Scenario: You're capturing form submissions via webhook and need to log them to Google Sheets.

Step 1: Add a Webhook trigger

Method: POST
Path: /form-submission
Authentication: None (for testing; add auth in production)

Step 2: Add a Google Sheets node set to "Append"

Configure it like this:

Operation: Append
Spreadsheet: Your spreadsheet
Sheet: Contacts
Columns to Insert: Name, Email, Phone, Status

Step 3: Map the incoming webhook data to sheet columns

In the "Values" section, reference the webhook body:

Name: {{ $json.body.name }}
Email: {{ $json.body.email }}
Phone: {{ $json.body.phone }}
Status: "New"

Step 4: Test with a POST request

Use curl or Postman:

curl -X POST https://your-n8n-instance.com/webhook/form-submission \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Charlie Brown",
    "email": "charlie@example.com",
    "phone": "555-0103"
  }'

Check your Google Sheet—the new row will appear instantly.

Want to update an existing row instead of appending?

Use the "Update" operation:

Operation: Update
Spreadsheet: Your spreadsheet
Sheet: Contacts
Key: Email (the column that identifies the row)
Values: Update Name, Status, Phone as needed

Advanced: Multi-Sheet Workflows and Error Handling

Once you master basic read/write, you can build more sophisticated workflows. Here's a real-world example: syncing leads from a webhook to multiple sheets based on their source.

Step 1: Webhook trigger

Accepts incoming lead data:

{
  "name": "Diana Prince",
  "email": "diana@example.com",
  "source": "facebook",
  "budget": "5000"
}

Step 2: Route based on source

Add an "If" node to branch the workflow:

Condition: source == "facebook"

Step 3: Append to the appropriate sheet

If source is "facebook," append to a "Facebook Leads" sheet:

Operation: Append
Spreadsheet: Your spreadsheet
Sheet: Facebook Leads
Columns: Name, Email, Budget, DateReceived
Values:
  Name: {{ $json.body.name }}
  Email: {{ $json.body.body.email }}
  Budget: {{ $json.body.budget }}
  DateReceived: {{ new Date().toISOString() }}

Otherwise, append to a "Other Leads" sheet.

Step 4: Add error handling

Wrap the Google Sheets operations in a "Try-Catch" node to gracefully handle failures:

Try: Google Sheets - Append node
Catch: Send notification if append fails

The catch block might look like this:

return {
  error: true,
  message: "Failed to append lead to Google Sheets",
  details: $json.error.message,
  lead: $json.body
};

You could then send this to a Slack channel or email for manual review. If you want to monitor failures across all your workflows, I'd recommend setting up VPS health check workflows that alert you to any repeated errors.

Advanced Tip: Filtering and Conditional Writes

Here's a workflow pattern I use constantly: only write data to Google Sheets if it meets certain criteria.

Step 1: Add a filter node after webhook trigger

Condition: email contains "@company.com" AND budget > 1000

This ensures only qualified leads get recorded.

Step 2: Append only if condition is true

The Google Sheets node only runs if the filter passes. Non-matching records can go to a separate sheet or be logged elsewhere.

Common Issues and Solutions

Issue: "Spreadsheet not found"

Make sure the Google account you authenticated with actually has access to the spreadsheet. Also verify the spreadsheet hasn't been moved to a shared drive (those require different permissions).

Issue: "Sheet name invalid"

Google Sheets node is case-sensitive. If your sheet is called "Contacts" but you're searching for "contacts," it will fail. Copy-paste the exact sheet name.

Issue: Rate limiting (too many reads/writes per minute)

Google Sheets has soft rate limits (~100 requests per minute per user). If you're doing bulk operations, add a 1-second delay between rows:

Add "Set" node between Google Sheets reads
Delay: {{ setTimeout(() => {}, 1000) }}

Issue: Need to read only specific columns?

Use the "Read Range" operation instead of "Read":

Range: A1:D100

This only reads columns A through D, rows 1 to 100.

Getting Started

You're ready to build. Here's your launch checklist:

Sign up for n8n Cloud (free tier includes 1,000 executions/month)
Create your first Google Sheet and populate it with test data
Add a Google Sheets node and authenticate
Build a simple read workflow to verify everything works
Add a webhook trigger and set up an append operation
Test with sample data before connecting to production

Need hosting? Hetzner VPS or Contabo VPS offer affordable servers if you want to self-host n8n instead of using the cloud version.

Outsource Your Automation

Don't have time? I build production n8n workflows, WhatsApp bots, and fully automated YouTube Shorts pipelines. Hire me on Fiverr — mention SYS3-DEVTO for priority. Or DM at chasebot.online.

Originally published on Automation Insider.

Edge TTS: The Free Text-to-Speech Engine Nobody Talks About

Raizan — Sat, 18 Apr 2026 08:00:39 +0000

What You'll Need

n8n Cloud or self-hosted n8n instance
Hetzner VPS or Contabo VPS if self-hosting
Python 3.8+ installed locally or on your server
Basic command-line familiarity
A text file or API endpoint with content to synthesize

What Is Edge TTS and Why Should You Care?
Setting Up Edge TTS on Your Machine
Integrating Edge TTS with n8n
Building a Production Workflow
Getting Started

What Is Edge TTS and Why Should You Care?

I discovered Edge TTS completely by accident while hunting for a free text-to-speech solution that didn't require expensive API keys or sketchy third-party services. What I found was Microsoft's hidden gem—a legitimate TTS engine that powers Microsoft Edge's built-in reader functionality.

Edge TTS is the text-to-speech engine that runs inside Microsoft Edge's "Read aloud" feature. It's been available for years, but almost nobody talks about it because Microsoft doesn't officially document it as a public API. The community reverse-engineered it, wrapped it in Python libraries, and now you can use it for free without authentication, rate limits, or corporate approval.

Here's what makes it genuinely special:

Natural voice quality. Edge TTS produces audio that sounds like actual humans, not the robotic Stephen-Hawking-era synth voices you'd expect from free tools. I've tested dozens of voices across 50+ languages, and the clarity is genuinely impressive.

No API key required. Unlike Google Cloud TTS (pay-as-you-go), AWS Polly (AWS account mandatory), or OpenAI's TTS, Edge TTS asks for nothing. No authentication. No billing. No rate-limit emails at 3 AM.

200+ voice options. Microsoft has trained models for various languages, accents, and genders. Want a British female voice? Australian male? Korean child voice? They're all there.

Fast processing. On a decent internet connection, you'll get audio files in seconds, not minutes.

Perfect for automation. This is where I use it most—building workflows that convert article text to audio, generate YouTube video voiceovers, create multilingual bot responses, or produce accessibility-friendly content automatically.

The catch? It's technically against Microsoft's terms of service (they say it's for Edge's reader feature only), but the community-maintained Python libraries have been stable for three years without takedown notices. If you're building commercial products, be aware of that risk.

Setting Up Edge TTS on Your Machine

Let me walk you through the simplest possible setup.

First, install the edge-tts Python package:

pip install edge-tts

That's it. You're done with setup. No credentials, no config files, no environment variables to juggle.

Let's test it immediately with a simple command-line call:

edge-tts --text "Hello, this is Edge TTS speaking" --write-media test_output.mp3 --voice en-US-AriaNeural

This does three things:

Takes your text string
Downloads the MP3 audio file
Saves it as test_output.mp3

Check your current directory—you'll see a fresh MP3 file. Play it. The voice quality will shock you if you've been using free TTS before.

Now let's list all available voices:

edge-tts --list-voices

You'll get output like this:

Name: af-ZA-AdriNeural
Name: af-ZA-WillemNeural
Name: am-ET-AmehaNeural
Name: am-ET-MekdesNeural
Name: ar-AE-FatimaNeural
Name: ar-AE-MohamedNeural
...and 200+ more

Pick a voice that matches your use case. For English, I usually default to en-US-AriaNeural (neutral American female) or en-GB-SoniaNeural (British female), but experiment.

Now let's write actual Python code to integrate this into your workflows:

import edge_tts
import asyncio
import os

async def text_to_speech(text, output_file, voice="en-US-AriaNeural", rate=0):
    communicate = edge_tts.Communicate(text=text, voice=voice, rate=rate)
    await communicate.save(output_file)
    return output_file

async def main():
    text_content = "Welcome to the world of automated audio generation. This is completely free and requires no API keys."
    output_path = "welcome_audio.mp3"
    voice_choice = "en-US-AriaNeural"

    result = await text_to_speech(text_content, output_path, voice_choice)
    print(f"Audio saved to {result}")

asyncio.run(main())

Run this script:

python tts_script.py

You'll have a professional-quality MP3 in seconds.

The rate parameter controls speech speed. Use -50 for slower speech, 0 for normal, 50 for faster. Handy for accessibility or for creating background narration that matches video pacing.

Integrating Edge TTS with n8n

This is where automation gets powerful. If you're running n8n Cloud or a self-hosted instance on Hetzner VPS, you can trigger TTS generation from any workflow.

Create a new workflow in n8n Cloud and add an "Execute Command" node (or "Run Script" if you're using the Python node in a self-hosted setup).

Here's the configuration for a simple HTTP-triggered workflow:

Node 1: HTTP Request trigger

Set up a webhook that accepts POST requests with a JSON body containing your text and voice preference.

Node 2: Function node (execute Python)

import edge_tts
import asyncio
import base64
import json

async def generate_audio(text_input, voice_name):
    output_file = f"/tmp/{voice_name}_output.mp3"
    communicate = edge_tts.Communicate(text=text_input, voice=voice_name, rate=0)
    await communicate.save(output_file)

    with open(output_file, "rb") as audio_file:
        audio_base64 = base64.b64encode(audio_file.read()).decode("utf-8")

    return audio_base64

text = $json.body.text
voice = $json.body.voice or "en-US-AriaNeural"

audio_data = asyncio.run(generate_audio(text, voice))

return {
    "audio_base64": audio_data,
    "voice_used": voice,
    "text_length": len(text),
    "status": "success"
}

Node 3: Send the response back

Use an HTTP Response node to return the base64-encoded audio or save it to cloud storage.

When you trigger this workflow via HTTP POST:

curl -X POST http://your-n8n-instance/webhook/tts \
  -H "Content-Type: application/json" \
  -d '{
    "text": "This workflow generated this audio automatically",
    "voice": "en-GB-SoniaNeural"
  }'

You'll get back a response with the audio file encoded in base64, ready to play, embed, or store.

Building a Production Workflow

Let me show you a real-world example: a workflow that converts blog posts into audio summaries and uploads them to cloud storage.

I'll build this with multiple steps:

Step 1: Fetch blog post content (HTTP Request node)

GET https://api.example.com/posts/latest
Authentication: Bearer YOUR_API_TOKEN
Response format: JSON with "title" and "content" fields

Step 2: Summarize the content (optional—use OpenAI or similar)

If your blog post is 3,000 words, you might want to summarize it to 500 words before generating audio (shorter file, faster generation).

Step 3: Generate audio with Edge TTS (Function node)

import edge_tts
import asyncio
import os
from datetime import datetime

async def create_podcast_audio(post_title, post_summary, voice_choice):
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"/tmp/podcast_{timestamp}.mp3"

    full_text = f"{post_title}. {post_summary}"

    communicate = edge_tts.Communicate(text=full_text, voice=voice_choice, rate=-10)
    await communicate.save(filename)

    file_size = os.path.getsize(filename)

    return {
        "file_path": filename,
        "file_size": file_size,
        "timestamp": timestamp,
        "duration_estimate": round(len(full_text) / 150, 1)
    }

title = $json.payload.title
summary = $json.payload.content
voice = "en-US-AriaNeural"

result = asyncio.run(create_podcast_audio(title, summary, voice))
return result

Step 4: Upload to AWS S3 (or any cloud storage)

Use n8n's built-in S3 node:

{
  "bucket": "your-bucket-name",
  "key": "podcasts/{{ $node['Function'].data.timestamp }}.mp3",
  "fileContent": "{{ $node['Function'].data.file_path }}",
  "acl": "public-read"
}

Step 5: Send notification (Slack, Email, or Webhook)

{
  "text": "New podcast audio generated",
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*Blog Audio Generated*\n*Title:* {{ $node['HTTP Request'].data.title }}\n*File Size:* {{ $node['Function'].data.file_size }} bytes\n*Listen:* https://your-bucket.s3.amazonaws.com/podcasts/{{ $node['Function'].data.timestamp }}.mp3"
      }
    }
  ]
}

This workflow runs on a schedule or webhook trigger, converts your latest blog post to audio, uploads it, and notifies your team—all without a single manual step.

If you want to go further, combine this with the techniques in How to Monitor Your VPS with n8n Health Check Workflows to ensure your audio generation service stays healthy, or use How to Build a Telegram Bot with n8n (No Code Required) to let users request audio generation on-demand.

Advanced: Handling Large-Scale Audio Generation

If you're generating hundreds of audio files, edge-tts can hit rate limits (Microsoft's servers will temporarily block you). Here's a production-ready approach:

import edge_tts
import asyncio
import time
from typing import List

async def generate_audio_batch(text_list: List[str], voice: str, delay_seconds: int = 2):
    results = []

    for idx, text in enumerate(text_list):
        try:
            output_file = f"/tmp/batch_{idx:04d}.mp3"
            communicate = edge_tts.Communicate(text=text, voice=voice, rate=0)
            await communicate.save(output_file)

Originally published on Automation Insider.

DEV Community: Raizan

Building a Crypto Price Alert Bot with n8n and CoinGecko

What You'll Need

Table of Contents

Understanding the Architecture

Setting Up Your First Webhook Trigger

Fetching Live Crypto Prices from CoinGecko

Building the Price Alert Logic

Sending Notifications

Advanced: Multi-Exchange Price Comparison

Error Handling & Rate Limiting

Getting Started

Outsource Your Automation

How to Use HuggingFace Inference API for Free Image Generation

What You'll Need

Table of Contents

Understanding HuggingFace Inference API

Setting Up Your API Key

Making Your First Free Image Generation Request

Integrating with n8n for Automated Workflows

Handling Rate Limits and Optimization

Getting Started

Outsource Your Automation

pm2 Process Manager: Keep Your Node.js Bots Running Forever

What You'll Need

Table of Contents

Why PM2 Matters for Bot Automation

Installation & Initial Setup

Running Your First Process

Clustering & Load Balancing

Monitoring & Logs in Real-Time

Auto-Restart on Server Reboot

Integration with n8n Webhooks

Automating Social Media Posts with n8n: Complete Guide

What You'll Need

Table of Contents

Why Automate Social Media Posts?

Setting Up Your n8n Instance

Connecting Your First Social Platform

Building a Multi-Platform Workflow

Scheduling Posts with Cron Triggers

Advanced: Content Batching and Analytics

Getting Started

Outsource Your Automation

How to Set Up Nginx Reverse Proxy with SSL (Let's Encrypt)

What You'll Need

Table of Contents

Understanding Nginx Reverse Proxy Architecture

Installing Nginx and Certbot

Configuring Your First Reverse Proxy

Setting Up SSL with Let's Encrypt

Securing Your Configuration

Advanced: Multiple Backend Services

Jupiter API Guide: Free Solana Price Data for Your Apps

What You'll Need

Table of Contents

Understanding Jupiter API and Why It Matters

Getting Your Free Jupiter API Key

Building Your First Price Data Query

Real-Time Solana Price Monitoring with n8n

Building a Lead Capture System with n8n and Typeform

What You'll Need

Table of Contents

Why Typeform + n8n Is a Game-Changer

Setting Up Your Typeform

Connecting n8n to Typeform

Building the Lead Capture Workflow

Adding Data Validation and Filtering

Storing Leads in Google Sheets

Sending Automated Follow-Up Emails

Testing and Deploying

Getting Started

Outsource Your Automation

How to Deploy n8n with Docker on Any VPS (2026 Guide)

What You'll Need

Table of Contents

Why Self-Host n8n on a VPS?

Setting Up Your VPS

Installing Docker

Deploying n8n with Docker Compose