Forem: Raizan

How to Build a YouTube Upload Bot with Node.js and OAuth2

Raizan — Tue, 05 May 2026 08:00:38 +0000

What You'll Need

n8n Cloud or self-hosted n8n for workflow orchestration
Hetzner VPS or Contabo VPS for hosting your Node.js bot
Namecheap if you need a domain for webhooks
Node.js 18+ installed locally
A Google/YouTube developer account with API credentials
FFmpeg installed (for video processing)
Basic understanding of OAuth2 flow

Understanding the YouTube Upload Workflow
Setting Up Google OAuth2 Credentials
Building the Core Node.js Bot
Handling OAuth2 Token Refresh
Implementing Video Upload Logic
Deploying and Monitoring
Getting Started

Understanding the YouTube Upload Workflow

I've built dozens of YouTube automation workflows over the past three years, and the pattern is always the same: authenticate once, grab an access token, upload videos, refresh tokens before they expire. The tricky part isn't the code—it's understanding when and why OAuth2 needs refreshing, and handling edge cases like failed uploads or network timeouts.

YouTube's Data API v3 requires OAuth2 because you're acting on behalf of a user's account. Unlike simple API keys, OAuth2 gives you delegated access that users can revoke anytime. Your bot will need to:

Exchange a refresh token for a short-lived access token
Use that token to upload video files to YouTube
Update video metadata (title, description, tags, privacy settings)
Handle token expiration gracefully

The beauty of building this in Node.js is speed and ecosystem maturity. Libraries like googleapis and dotenv are battle-tested in production. If you're comparing lightweight AI options for automating video descriptions or titles during upload, Claude Haiku vs GPT-4o Mini for Automation Pipelines walks through real trade-offs.

Setting Up Google OAuth2 Credentials

Head to Google Cloud Console and create a new project. I'll walk through the exact steps:

Click "Select a Project" → "New Project"
Name it something obvious like youtube-uploader-bot
Once created, navigate to "APIs & Services" → "Credentials"
Click "Create Credentials" → "OAuth 2.0 Client ID"
You'll be prompted to create a consent screen first. Choose "External" for user type
Fill in the app name, user support email, and developer contact
On "Scopes," add https://www.googleapis.com/auth/youtube.upload
Back to Credentials, create an OAuth 2.0 Client ID as a "Desktop application"
Download the JSON file—this contains your client_id and client_secret

Save that JSON file as credentials.json in your project root. Never commit this to git.

Now create a .env file to store sensitive values:

GOOGLE_CLIENT_ID=YOUR_CLIENT_ID_HERE
GOOGLE_CLIENT_SECRET=YOUR_CLIENT_SECRET_HERE
REDIRECT_URI=http://localhost:3000/oauth2callback
YOUTUBE_CHANNEL_ID=UCXXXXXXXXXXXXXXXXXX
NODE_ENV=production

Building the Core Node.js Bot

Install dependencies first:

npm init -y
npm install googleapis dotenv express axios path os stream

Create auth.js to handle the OAuth2 flow:

const { google } = require('googleapis');
const fs = require('fs');
require('dotenv').config();

const oauth2Client = new google.auth.OAuth2(
  process.env.GOOGLE_CLIENT_ID,
  process.env.GOOGLE_CLIENT_SECRET,
  process.env.REDIRECT_URI
);

function getAuthUrl() {
  const scopes = ['https://www.googleapis.com/auth/youtube.upload'];

  const url = oauth2Client.generateAuthUrl({
    access_type: 'offline',
    scope: scopes,
    prompt: 'consent'
  });

  return url;
}

function saveRefreshToken(tokens) {
  const tokenPath = 'tokens.json';
  fs.writeFileSync(tokenPath, JSON.stringify(tokens, null, 2));
  console.log(`Refresh token saved to ${tokenPath}`);
}

function loadRefreshToken() {
  const tokenPath = 'tokens.json';
  if (fs.existsSync(tokenPath)) {
    const tokens = JSON.parse(fs.readFileSync(tokenPath, 'utf8'));
    oauth2Client.setCredentials(tokens);
    return tokens;
  }
  return null;
}

async function exchangeCodeForToken(code) {
  try {
    const { tokens } = await oauth2Client.getToken(code);
    saveRefreshToken(tokens);
    oauth2Client.setCredentials(tokens);
    return tokens;
  } catch (error) {
    console.error('Error exchanging code for token:', error.message);
    throw error;
  }
}

async function getAccessToken() {
  const tokens = loadRefreshToken();

  if (!tokens) {
    throw new Error('No refresh token found. Run initial authentication first.');
  }

  oauth2Client.setCredentials(tokens);

  if (oauth2Client.isTokenExpiring()) {
    console.log('Token expiring, refreshing...');
    const { credentials } = await oauth2Client.refreshAccessToken();
    saveRefreshToken(credentials);
    oauth2Client.setCredentials(credentials);
    return credentials.access_token;
  }

  return tokens.access_token;
}

module.exports = {
  oauth2Client,
  getAuthUrl,
  exchangeCodeForToken,
  getAccessToken,
  loadRefreshToken,
  saveRefreshToken
};

Now create server.js to set up the Express server and handle the OAuth callback:

const express = require('express');
const { getAuthUrl, exchangeCodeForToken, loadRefreshToken } = require('./auth');
require('dotenv').config();

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

app.get('/auth', (req, res) => {
  const authUrl = getAuthUrl();
  res.redirect(authUrl);
});

app.get('/oauth2callback', async (req, res) => {
  const code = req.query.code;

  if (!code) {
    return res.status(400).send('No authorization code received');
  }

  try {
    const tokens = await exchangeCodeForToken(code);
    res.send('Authorization successful! You can close this window and run your upload script.');
  } catch (error) {
    console.error('OAuth error:', error.message);
    res.status(500).send('Authorization failed: ' + error.message);
  }
});

app.get('/health', (req, res) => {
  const tokens = loadRefreshToken();
  if (tokens) {
    res.json({ status: 'authenticated', channelId: process.env.YOUTUBE_CHANNEL_ID });
  } else {
    res.json({ status: 'not_authenticated', authUrl: 'http://localhost:3000/auth' });
  }
});

app.listen(PORT, () => {
  console.log(`Server running on http://localhost:${PORT}`);
  console.log(`Visit http://localhost:${PORT}/auth to authenticate`);
});

Handling OAuth2 Token Refresh

Token refresh is critical. YouTube access tokens expire after one hour, but refresh tokens last much longer (until revoked). The oauth2Client.isTokenExpiring() check in auth.js handles this automatically, but let me show you a more robust approach for production:

Create tokenManager.js:

const fs = require('fs');
const { oauth2Client } = require('./auth');
require('dotenv').config();

const TOKEN_FILE = 'tokens.json';
const TOKEN_REFRESH_THRESHOLD = 300; // Refresh if expiring in next 5 minutes

class TokenManager {
  constructor() {
    this.tokens = this.loadTokens();
  }

  loadTokens() {
    if (fs.existsSync(TOKEN_FILE)) {
      return JSON.parse(fs.readFileSync(TOKEN_FILE, 'utf8'));
    }
    return null;
  }

  saveTokens(tokens) {
    fs.writeFileSync(TOKEN_FILE, JSON.stringify(tokens, null, 2));
    this.tokens = tokens;
  }

  isExpiringSoon() {
    if (!this.tokens || !this.tokens.expiry_date) {
      return true;
    }
    const now = Date.now();
    const expiryTime = this.tokens.expiry_date;
    return (expiryTime - now) < (TOKEN_REFRESH_THRESHOLD * 1000);
  }

  async getValidAccessToken() {
    if (!this.tokens) {
      throw new Error('No tokens found. Authenticate first.');
    }

    oauth2Client.setCredentials(this.tokens);

    if (this.isExpiringSoon()) {
      console.log(`[${new Date().toISOString()}] Token expiring soon, refreshing...`);
      try {
        const { credentials } = await oauth2Client.refreshAccessToken();
        this.saveTokens(credentials);
        oauth2Client.setCredentials(credentials);
        console.log(`[${new Date().toISOString()}] Token refreshed successfully`);
        return credentials.access_token;
      } catch (error) {
        console.error('Token refresh failed:', error.message);
        throw error;
      }
    }

    return this.tokens.access_token;
  }
}

module.exports = new TokenManager();

Implementing Video Upload Logic

Now for the main event—uploading videos. Create uploader.js:

const { google } = require('googleapis');
const fs = require('fs');
const path = require('path');
const tokenManager = require('./tokenManager');
const { oauth2Client } = require('./auth');
require('dotenv').config();

const youtube = google.youtube('v3');

async function uploadVideo(videoFilePath, metadata) {
  try {
    const accessToken = await tokenManager.getValidAccessToken();
    oauth2Client.setCredentials({ access_token: accessToken });

    const fileName = path.basename(videoFilePath);
    const fileSize = fs.statSync(videoFilePath).size;

    console.log(`[${new Date().toISOString()}] Starting upload: ${fileName} (${fileSize} bytes)`);

    const response = await youtube.videos.insert(
      {
        part: 'snippet,status,processingDetails',
        requestBody: {
          snippet: {
            title: metadata.title || 'Untitled Video',
            description: metadata.description || '',
            tags: metadata.tags || [],
            categoryId: metadata.categoryId || '22',
            defaultLanguage: metadata.defaultLanguage || 'en',
            defaultAudioLanguage: metadata.defaultAudioLanguage || 'en'
          },
          status: {
            privacyStatus: metadata.privacyStatus || 'private',
            publishAt: metadata.publishAt || null,
            selfDeclaredMadeForKids: metadata.madeForKids || false
          }

Originally published on Automation Insider.

The Developer Guide to Choosing a Domain Registrar in 2026

Raizan — Mon, 04 May 2026 08:01:06 +0000

What You'll Need

Namecheap (or competitor registrars listed below)
A Hetzner VPS or Contabo VPS if you're planning to host automation workflows
n8n Cloud for workflow automation (optional, but pairs well with your domain)
10 minutes and a credit card

Why Domain Choice Actually Matters for Developers
The Core Registrar Features You Need
Top Registrars Ranked by Use Case
DNS Management: Where Automation Happens
Pricing Isn't Everything (But API Access Is)
Getting Started

Why Domain Choice Actually Matters for Developers

I used to think a domain registrar was just a domain registrar. Buy it somewhere cheap, move on. Then I started building automation workflows and realized—your registrar choice directly affects how quickly you can deploy, test, and manage infrastructure.

When you're setting up webhook endpoints, SSL certificates, or DNS records for a new staging environment, a clunky registrar dashboard costs you hours. When you need to automate DNS updates via API, a registrar without programmatic access becomes a bottleneck.

For developers in 2026, this choice matters as much as picking your hosting provider. In fact, it pairs directly with your infrastructure decisions. If you're deploying on a Hetzner VPS or Contabo VPS, your registrar needs to play nice with that environment through clean DNS delegation and API access.

The Core Registrar Features You Need

Before comparing specific platforms, let's define what actually matters:

1. DNS API Access — Can you programmatically manage DNS records? This is non-negotiable if you're automating anything. Most registrars offer REST APIs now, but the quality varies wildly.

2. Nameserver Flexibility — Can you point to custom nameservers without friction? This is essential for delegating to your VPS or a managed DNS provider.

3. WHOIS Privacy — Does it come included or cost extra? In 2026, this should be standard.

4. SSL Certificate Bundling — Are free or cheap SSL certs included? (They usually are, but verify.)

5. Bulk Operations — Can you manage 10+ domains efficiently, or does the UI require clicking through dialogs for each one?

6. Uptime and Support Quality — Registrars don't fail often, but when they do, support response time matters for critical projects.

7. Transfer Locks and Authorization — How straightforward is the process if you need to move domains later?

Top Registrars Ranked by Use Case

Best Overall for Developers: Namecheap

Namecheap remains my top recommendation. Here's why:

DNS API: Full REST API with clear documentation. You can automate ACME challenges for Let's Encrypt without thinking.
Price: Domains start around $8.88/year for .com (after promotional pricing). Renewal rates are honest, not inflated.
WHOIS Privacy: Included free with every domain.
Bulk Management: The dashboard handles 50+ domains without lag.
Uptime: Consistently reliable. No surprise nameserver outages in my 8+ years as a customer.

When to use Namecheap: You're building automation around your domains, need clean API access, and want predictable pricing.

When to skip it: If you need enterprise-grade white-label solutions (though they offer those too, at higher tiers).

Best for Cost-Conscious Builders: Google Domains

Google Domains offers competitive pricing and a clean UI, but—and I'll be direct—it's a good option only if you're not planning to automate. API access is limited compared to Namecheap. Google handles DNS management well for manual use, but if you're building workflows that touch your DNS layer, you'll hit walls.

When to use it: Personal projects, blogs, or sites where the domain is set-and-forget.

Best for Enterprise Scale: Route 53 (AWS)

If you're already deep in the AWS ecosystem and managing infrastructure through code, Route 53 is genuinely excellent. But—critical detail—you're not really "registering" through Route 53 in the traditional sense. You register with any registrar, then point to Route 53 for DNS management.

This is actually the model I recommend for serious automation projects. Buy cheap domains from Namecheap, then delegate DNS to Route 53. Separating registration from DNS gives you maximum flexibility.

When to use it: Infrastructure-as-code projects, CloudFormation templates, or teams already using AWS.

Best for European Compliance: EasyDNS or Gandi

If GDPR compliance or data residency is a requirement, EasyDNS (Canada-based) and Gandi (France-based) are stronger choices. They're transparent about data handling and offer EU-resident DNS servers.

When to use it: EU-based businesses or privacy-focused projects.

DNS Management: Where Automation Happens

Here's where the rubber meets the road. Once you own the domain, everything flows through DNS.

Let's say you're running an n8n Cloud instance and need to point a custom domain to it. You'll:

Create a CNAME record pointing your domain to the n8n endpoint
Verify DNS propagation
Configure SSL

With a good registrar's API, you can automate step 1 entirely. Here's what that looks like using Namecheap's API:

curl -X POST "https://api.namecheap.com/api/xml.response" \
  -d "ApiUser=YOUR_API_USER" \
  -d "ApiKey=YOUR_API_KEY" \
  -d "UserName=YOUR_USERNAME" \
  -d "Command=namecheap.domains.dns.setHosts" \
  -d "DomainName=example.com" \
  -d "TLD=com" \
  -d "SLD=example" \
  -d "HostName1=@" \
  -d "RecordType1=A" \
  -d "Address1=192.0.2.1" \
  -d "TTL1=1800" \
  -d "HostName2=www" \
  -d "RecordType2=CNAME" \
  -d "Address2=example.com" \
  -d "TTL2=1800"

This is the kind of operation that should take seconds, not manual clicks. A registrar without solid API support kills this workflow.

💡 Fast-Track Your Project: Don't want to configure this yourself? I build custom n8n pipelines and bots. Message me with code SYS3-DEVTO.

Pricing Isn't Everything (But API Access Is)

I see developers get lured by $0.99 domain promos and then regret it when renewal costs $18. Here's the reality in 2026:

First-year pricing is a lie. It's designed to lock you in. Look at year-two renewal rates.

Example comparison:

Namecheap .com: $8.88 first year (promo), $12.98 renewal
GoDaddy .com: $0.99 first year (promo), $15.99 renewal
Google Domains .com: $12.00 consistently

Over five years, Namecheap usually wins even with higher first-year costs because the renewal rate is predictable.

But here's what matters more: If your registrar doesn't have an API, you're paying a hidden cost in time and friction.

When you're spinning up staging environments or automating infrastructure, every extra manual step is expensive. That's why I recommend investing slightly more in a registrar with good API access rather than saving $2 per domain with a registrar that forces manual DNS management.

Getting Started

Here's your action plan:

1. Pick a registrar based on your use case:

Automation-heavy: Namecheap
AWS ecosystem: Route 53
EU compliance: EasyDNS or Gandi

2. If you're hosting automation workflows, pair your domain choice with proper infrastructure. Whether you're using a Hetzner VPS or Contabo VPS for your backend, point your domain's nameservers there and use your registrar's API for programmatic management.

3. Document your DNS setup in code. Whether it's Terraform, a shell script, or an n8n workflow, your DNS records should be reproducible.

4. Set up DNSSEC if your registrar supports it. It's a free security layer most developers skip.

5. Enable API access in your registrar's account immediately. Even if you don't need it today, you will soon.

If you're building anything serious—personal brand sites, automation infrastructure, or scalable projects—don't treat the registrar as a commodity purchase. Spend 20 minutes now evaluating registrar APIs. You'll save hours later.

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.

Automating PDF Report Generation with n8n and Node.js

Raizan — Sun, 03 May 2026 08:00:28 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for hosting
Namecheap if domain needed
Node.js 16+ installed locally
A PDF generation library (we'll use PDFKit)
Basic knowledge of n8n workflows

The PDF Generation Challenge
Setting Up Your n8n Workflow
Building a Node.js PDF Service
Connecting n8n to Your PDF Generator
Real-World Example: Sales Report Automation
Getting Started

The PDF Generation Challenge

I've been automating workflows for three years now, and PDF generation is one of the most common requests I get. The challenge isn't just creating a PDF—it's doing it reliably, at scale, without manual intervention.

Most no-code platforms struggle with dynamic PDF creation because they lack granular control over styling, layout, and data injection. That's where combining n8n Cloud with a custom Node.js service becomes powerful. You get the orchestration power of n8n with the flexibility of server-side rendering.

Before we dive in, I should mention that if you're deciding between a cloud solution and self-hosting, the considerations differ when you're generating files. I've written about self-hosted n8n vs n8n Cloud before—self-hosted gives you full control over file storage and processing power, which matters for high-volume PDF generation.

Setting Up Your n8n Workflow

First, let's create the orchestration layer in n8n. I'm using n8n Cloud for this example, but the workflow translates directly to self-hosted instances.

Create a new workflow and start with a Webhook trigger:

{
  "nodes": [
    {
      "parameters": {
        "path": "generate-report",
        "httpMethod": "POST",
        "responseMode": "lastNode",
        "options": {}
      },
      "name": "Report Webhook",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1,
      "position": [250, 300]
    }
  ]
}

This webhook will accept POST requests with your report data. Next, add a function node to parse and validate incoming data:

const data = $input.all();
const reportRequest = data[0].json.body;

if (!reportRequest.companyName || !reportRequest.salesData || !reportRequest.period) {
  throw new Error('Missing required fields: companyName, salesData, period');
}

return [
  {
    json: {
      companyName: reportRequest.companyName,
      salesData: reportRequest.salesData,
      period: reportRequest.period,
      generatedAt: new Date().toISOString(),
      filename: `Report_${reportRequest.companyName}_${reportRequest.period}.pdf`
    }
  }
];

Now add an HTTP request node that will call your PDF generation service:

{
  "parameters": {
    "url": "http://your-pdf-service.local:3000/generate-pdf",
    "method": "POST",
    "headerParametersUi": {
      "parameter": [
        {
          "name": "Content-Type",
          "value": "application/json"
        }
      ]
    },
    "sendBody": true,
    "bodyParametersJson": "={{ $node[\"Parse Report Data\"].json }}"
  },
  "name": "Call PDF Generator",
  "type": "n8n-nodes-base.httpRequest",
  "typeVersion": 4,
  "position": [450, 300]
}

Building a Node.js PDF Service

Your Node.js service is where the actual PDF magic happens. I'm using Express and PDFKit for this—it gives you pixel-perfect control over layouts.

Create a new Node.js project:

mkdir pdf-generator-service
cd pdf-generator-service
npm init -y
npm install express pdfkit axios dotenv cors

Create your main server file:

const express = require('express');
const PDFDocument = require('pdfkit');
const fs = require('fs');
const path = require('path');
const cors = require('cors');
require('dotenv').config();

const app = express();
app.use(express.json());
app.use(cors());

const PDF_OUTPUT_DIR = path.join(__dirname, 'generated-pdfs');
if (!fs.existsSync(PDF_OUTPUT_DIR)) {
  fs.mkdirSync(PDF_OUTPUT_DIR, { recursive: true });
}

app.post('/generate-pdf', async (req, res) => {
  try {
    const { companyName, salesData, period, filename } = req.body;

    const pdfPath = path.join(PDF_OUTPUT_DIR, filename);
    const doc = new PDFDocument({
      size: 'A4',
      margin: 50,
      info: {
        Title: `Sales Report - ${period}`,
        Author: companyName,
        Subject: 'Automated Sales Report'
      }
    });

    const writeStream = fs.createWriteStream(pdfPath);
    doc.pipe(writeStream);

    doc.fontSize(24).font('Helvetica-Bold').text('SALES REPORT', { align: 'center' });
    doc.moveDown();
    doc.fontSize(12).font('Helvetica').text(`Company: ${companyName}`, { align: 'center' });
    doc.fontSize(12).text(`Period: ${period}`, { align: 'center' });
    doc.fontSize(10).text(`Generated: ${new Date().toLocaleString()}`, { align: 'center' });

    doc.moveTo(50, doc.y).lineTo(545, doc.y).stroke();
    doc.moveDown(1);

    doc.fontSize(14).font('Helvetica-Bold').text('Sales Summary', { underline: true });
    doc.moveDown(0.5);

    let totalRevenue = 0;
    let totalUnits = 0;

    if (Array.isArray(salesData) && salesData.length > 0) {
      const tableTop = doc.y + 20;
      const col1X = 70;
      const col2X = 250;
      const col3X = 400;
      const rowHeight = 25;

      doc.fontSize(11).font('Helvetica-Bold');
      doc.text('Product', col1X, tableTop);
      doc.text('Units Sold', col2X, tableTop);
      doc.text('Revenue', col3X, tableTop);

      doc.moveTo(50, tableTop + 15).lineTo(545, tableTop + 15).stroke();
      doc.font('Helvetica').fontSize(10);

      salesData.forEach((item, index) => {
        const rowY = tableTop + 20 + index * rowHeight;
        doc.text(item.product || 'N/A', col1X, rowY);
        doc.text(item.units || '0', col2X, rowY);
        doc.text(`$${item.revenue || 0}`, col3X, rowY);
        totalRevenue += item.revenue || 0;
        totalUnits += item.units || 0;
      });

      const summaryY = tableTop + 20 + salesData.length * rowHeight + 20;
      doc.moveTo(50, summaryY).lineTo(545, summaryY).stroke();
      doc.fontSize(11).font('Helvetica-Bold');
      doc.text('TOTALS', col1X, summaryY + 10);
      doc.text(totalUnits.toString(), col2X, summaryY + 10);
      doc.text(`$${totalRevenue.toFixed(2)}`, col3X, summaryY + 10);
    }

    doc.moveDown(3);
    doc.fontSize(10).font('Helvetica').text('This is an automatically generated report. No signature required.', {
      align: 'center',
      color: '#999999'
    });

    doc.end();

    writeStream.on('finish', () => {
      const fileBuffer = fs.readFileSync(pdfPath);
      res.setHeader('Content-Type', 'application/pdf');
      res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
      res.setHeader('Content-Length', fileBuffer.length);
      res.send(fileBuffer);

      fs.unlink(pdfPath, (err) => {
        if (err) console.error('Error deleting temp file:', err);
      });
    });

    writeStream.on('error', (err) => {
      console.error('Stream error:', err);
      res.status(500).json({ error: 'PDF generation failed', details: err.message });
    });

  } catch (error) {
    console.error('PDF generation error:', error);
    res.status(500).json({ error: 'PDF generation failed', details: error.message });
  }
});

app.get('/health', (req, res) => {
  res.json({ status: 'PDF service running', timestamp: new Date().toISOString() });
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`PDF generation service listening on port ${PORT}`);
});

Create a .env file:

PORT=3000
NODE_ENV=development

Start the service:

node index.js

You should see: PDF generation service listening on port 3000

Connecting n8n to Your PDF Generator

Now let's complete the n8n workflow to handle the response and store your PDFs.

In your n8n workflow, add a node to save the PDF file. Add a Set node after your HTTP request:

const pdfBuffer = $input.all()[0].binary.data;
const filename = $input.all()[0].json.filename || 'report.pdf';

return [
  {
    json: {
      filename: filename,
      size: pdfBuffer.length,
      mimeType: 'application/pdf'
    },
    binary: {
      data: pdfBuffer
    }
  }
];

Next, add a Write Binary File node to persist the PDF:

{
  "parameters": {
    "fileName": "={{ $node[\"Set\"].json.filename }}",
    "dataPropertyName": "data",
    "options": {
      "outputFormat": "saveAs"
    }
  },
  "name": "Save PDF File",
  "type": "n8n-nodes-base.writeBinaryFile",
  "typeVersion": 1,
  "position": [650, 300]
}

If you're using self-hosted n8n, you might want to check out my guide on setting up Nginx as a reverse proxy with SSL so your webhook endpoint is secure when receiving sensitive report data.

Finally, add a response node to confirm success:

{
  "parameters": {
    "responseCode": 200,
    "options": {}
  },
  "name": "Return Success",
  "type": "n8n-

Originally published on Automation Insider.

Webhook Fundamentals: What They Are and How to Use Them

Raizan — Sat, 02 May 2026 08:00:41 +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
A code editor (VS Code recommended)
cURL or Postman for testing webhooks
Basic familiarity with JSON and HTTP requests

Understanding Webhooks: The Real-Time Solution
How Webhooks Actually Work
Setting Up Your First Webhook in n8n
Securing and Validating Webhooks
Common Webhook Patterns and Use Cases
Troubleshooting Webhook Issues
Getting Started

Understanding Webhooks: The Real-Time Solution

I've been automating workflows for years, and I can tell you that webhooks are the difference between clunky, scheduled integrations and truly responsive automation. Let me explain what's actually happening under the hood.

A webhook is an HTTP callback—essentially a way for one application to send real-time data to another application the moment something happens. Instead of your workflow constantly asking "did anything change yet?" (polling), a webhook is the source application saying "something just happened, here's the data."

Think of it like this: polling is checking your mailbox every hour. A webhook is the postman knocking on your door the moment mail arrives.

Why does this matter for automation? Speed. Reliability. Reduced API costs. If you're using n8n to replace expensive SaaS tools, webhooks cut your infrastructure costs dramatically because you're not hammering APIs with constant requests.

How Webhooks Actually Work

The webhook flow is straightforward but powerful:

Event triggers in the source application (a new Stripe payment, a form submission, a GitHub commit)
Source app sends HTTP POST request to your webhook URL with the event data
Your webhook receiver (n8n, your server, whatever) processes that data
Workflow executes based on the incoming data
Optional: Response sent back to the source application

The magic is that this all happens in milliseconds. No scheduled checks. No delays. Just instant reaction.

Here's what a typical webhook payload looks like:

{
  "event": "payment.completed",
  "timestamp": "2024-01-15T14:32:00Z",
  "data": {
    "payment_id": "pay_1234567890",
    "amount": 9999,
    "currency": "USD",
    "customer_id": "cus_9876543210",
    "status": "succeeded",
    "metadata": {
      "order_id": "ord_555",
      "customer_email": "user@example.com"
    }
  }
}

The source app doesn't care if your webhook succeeds or fails immediately—it just sends the data. That's why you need to build error handling into your workflow.

Setting Up Your First Webhook in n8n

I'm going to walk you through creating a production-ready webhook that captures data and processes it. I'll use n8n Cloud for this example, but the principles are identical for self-hosted.

Step 1: Create the Webhook Trigger

In n8n, add a new workflow and place a Webhook trigger node. Here's the configuration:

Click Add trigger → Webhook
Set HTTP Method to POST
Set Response Code to 200
Copy the Webhook URL (this is your public endpoint)

The URL will look like:

https://your-instance.n8n.cloud/webhook/unique-id-here

If you're self-hosting on Hetzner or Contabo, your URL might be:

https://automation.yourdomain.com/webhook/stripe-payments

Step 2: Parse the Incoming Data

Add a Set node to structure the webhook payload. Here's a real example that extracts Stripe payment data:

{
  "paymentId": "{{$json.data.payment_id}}",
  "amount": "{{$json.data.amount}}",
  "currency": "{{$json.data.currency}}",
  "customerId": "{{$json.data.customer_id}}",
  "status": "{{$json.data.status}}",
  "customerEmail": "{{$json.data.metadata.customer_email}}",
  "orderReference": "{{$json.data.metadata.order_id}}",
  "processedAt": "{{$now.toIso()}}"
}

This cleans up the raw webhook data into a standardized format your workflow can reliably work with.

Step 3: Route Based on Event Type

Add a Switch node to handle different webhook events:

Switch Node Expression:
$json.event

Conditions:
- payment.completed → Send to spreadsheet
- payment.failed → Send alert email
- charge.refunded → Log to database
- Default → Log to error handler

Step 4: Send Data to Your Destination

If you're storing payment data, you might send it to Google Sheets using n8n as a free database. Add a Google Sheets node:

Spreadsheet: "Payments"
Sheet: "All Transactions"
Options:
- Columns: paymentId, amount, currency, customerId, customerEmail, orderReference, status, processedAt
- Include Column Headers: true

Or if you need a proper database, use a Postgres node:

INSERT INTO payments (
  payment_id,
  amount,
  currency,
  customer_id,
  customer_email,
  order_reference,
  status,
  processed_at
) VALUES (
  $1, $2, $3, $4, $5, $6, $7, $8
)

Map your n8n variables to these placeholders.

Securing and Validating Webhooks

Here's where most people mess up: they treat webhooks like a public API endpoint. Don't do that. Anyone can send data to your webhook URL if they know it exists.

Implement Signature Verification

Most services (Stripe, GitHub, Slack) sign their webhooks with an HMAC signature. Here's how Stripe does it:

Stripe generates a timestamp
Stripe creates a signature using SHA-256 and your webhook secret
Stripe sends both in the Stripe-Signature header

In n8n, add a Code node to verify this before processing:

const crypto = require('crypto');

const signature = $request.headers['stripe-signature'];
const secret = 'whsec_your_webhook_secret';
const timestamp = signature.split(',')[0].split('=')[1];
const signedContent = `${timestamp}.${$json.body}`;

const expectedSignature = crypto
  .createHmac('sha256', secret)
  .update(signedContent)
  .digest('hex');

const receivedSignature = signature.split(',')[1].split('=')[1];

if (expectedSignature === receivedSignature) {
  return [{ valid: true }];
} else {
  return [{ valid: false, error: 'Invalid signature' }];
}

Add a Switch node after this:

If valid === true → continue processing
If valid === false → return 401 Unauthorized and stop

Use Webhook Secrets

In your webhook configuration, always set a secret. When you expose your webhook URL publicly, append a token:

https://automation.yourdomain.com/webhook/stripe-payments?secret=sk_live_abc123xyz789

Then in n8n's Webhook node, under Authentication, select your authentication method and validate this token before any processing happens.

Common Webhook Patterns and Use Cases

Pattern 1: Real-Time Form Processing

When someone submits a form on your website, immediately store data and send a confirmation email:

Website form → webhook trigger
Validate email format
Save to database or Google Sheets
Send confirmation email via SendGrid
Return 200 success

Pattern 2: Multi-Step Integrations

This is where webhooks shine. If you're automating social media posts with n8n, you could:

Webhook triggered by new blog post
Parse the post content
Generate social media snippets (via OpenAI API)
Post to Twitter, LinkedIn, Instagram
Log results to Airtable

Pattern 3: Error Handling and Retries

Webhooks can fail. Your server might be down. Add robustness:

const maxRetries = 3;
let attempts = 0;
let success = false;

while (attempts < maxRetries && !success) {
  try {
    attempts++;
    const response = await fetch('https://your-api.com/endpoint', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify($json)
    });
    if (response.ok) {
      success = true;
    }
  } catch (error) {
    if (attempts === maxRetries) {
      throw new Error(`Failed after ${maxRetries} attempts: ${error.message}`);
    }
    await new Promise(resolve => setTimeout(resolve, 1000 * attempts));
  }
}

return [{ success }];

Pattern 4: Batching Webhooks

If you receive thousands of webhooks per minute, batch them before processing:

Webhook received → store in Redis/Postgres with timestamp
Every 30 seconds, fetch all pending items
Process batch as single operation
Mark as processed

This reduces database load dramatically.

Troubleshooting Webhook Issues

Problem: Webhook not being called

Verify the URL is correct and publicly accessible
Check your firewall/security groups (port 443 for HTTPS)
Confirm the webhook is "enabled" in the source application
Test with cURL:

curl -X POST https://your-webhook-url \
  -H "Content-Type: application/json" \
  -d '{"test": "data"}'

Problem: Webhooks calling but n8n says "invalid"

Check the HTTP method matches (POST vs GET)
Verify authentication token is correct
Look at n8n's webhook logs for the exact error
Check if your firewall is blocking the request

Problem: Webhook times out

Your n8n workflow is taking too long. The source app will retry if you don't respond within a few seconds. Solution:

Acknowledge immediately: Return 200 as soon as webhook arrives
Process asynchronously: Use the Execute Workflow Trigger node to run heavy processing in the background

Problem: Duplicate webhook executions

Add a deduplication check using the webhook's unique ID:

const webhookId = $json.id;
const cached = $request.headers['x-cached'] === 'true';

if (cached) {
  return [{ duplicate: true, skipped: true }];
}

// Continue processing

Getting Started

Ready to implement webhooks in your automation? Here's your next step:

Sign up for n8n Cloud if you haven't already (

Originally published on Automation Insider.

How to Reduce Your SaaS Bill with Self-Hosted Alternatives

Raizan — Fri, 01 May 2026 08:00:26 +0000

What You'll Need

n8n Cloud or self-hosted n8n for workflow automation
Hetzner VPS or Contabo VPS for hosting your self-hosted stack
Namecheap if you need a custom domain for your applications
DigitalOcean as an alternative hosting option
Basic familiarity with Docker and command-line interfaces
Around 30 minutes to set up your first stack

The Real Cost of SaaS Bloat
Where Self-Hosted Wins
Building Your First Self-Hosted Stack
Migration Strategy: Moving Off Expensive Tools
Security and Maintenance
Getting Started

The Real Cost of SaaS Bloat

I used to have 14 active SaaS subscriptions. Slack at $8/user, GitHub at $4/user, Zapier for automation, Make for backup, text-to-speech services, image processing tools, video editing APIs—the list went on. At the end of every month, I'd watch roughly $2,400 disappear from my company's account.

The problem isn't that these tools are bad. They're excellent. But when you're running a small team or bootstrapped startup, that money could be reinvested in actual product development or hiring. I decided to audit which tools were actually worth their cost and which ones I could replace.

Here's what I discovered: about 70% of what I was paying for could be handled by self-hosted open-source alternatives running on a $10-30/month VPS. The remaining 30% were genuinely specialized services worth keeping (like Stripe for payments—there's no good self-hosted alternative).

This shift didn't happen overnight, but in 12 months, I cut my SaaS bill from $2,400 to under $400 monthly. More importantly, I gained complete control over my data and workflows.

Where Self-Hosted Wins

Not every SaaS should be replaced. But certain categories are ripe for disruption:

Workflow Automation: Tools like Zapier charge based on tasks or users. When you move to self-hosted n8n, you pay once for the server and can create unlimited workflows. If you're trying to decide between cloud and self-hosted, our detailed comparison of self-hosted n8n vs n8n Cloud breaks down exactly when each makes sense.

Media Processing: APIs for text-to-speech, video transcoding, and image manipulation are absurdly expensive at scale. I replaced multiple services with Edge TTS, which is completely free and requires no API keys. For video work, ffmpeg is a beast—command-line based but incredibly powerful once you learn the syntax.

Internal Tools: Databases, documentation systems, project management dashboards—these don't need the polish of SaaS alternatives when you're the only one using them.

Data Processing: ETL pipelines, data warehousing, and analytics. Self-hosted solutions let you avoid per-query or per-gigabyte pricing.

Email Infrastructure: Postfix + Dovecot are ancient but rock-solid for managing your own mail server, though this one requires the most operational attention.

Building Your First Self-Hosted Stack

Let me walk you through setting up a practical stack that handles workflow automation, text-to-speech, and basic media processing on a single VPS.

Step 1: Choose and Configure Your VPS

I recommend Hetzner VPS for cost-effectiveness or Contabo VPS if you want more storage. For most workflows, a 4-core/8GB RAM instance is sufficient. Here's what I deploy:

#!/bin/bash
# Run this as root after SSH into your fresh VPS

# Update system packages
apt update && apt upgrade -y

# Install Docker
apt install -y apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/debian/gpg | apt-key add -
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable"
apt install -y docker-ce docker-ce-cli containerd.io

# Install Docker Compose
curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

# Create app directory
mkdir -p /opt/selfhosted
cd /opt/selfhosted

# Install Nginx as reverse proxy
apt install -y nginx

# Create Nginx config directory
mkdir -p /etc/nginx/sites-available

Step 2: Deploy n8n for Automation

n8n is where the magic happens. Create a docker-compose.yml:

version: '3.8'

services:
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    environment:
      - N8N_HOST=workflow.yourdomain.com
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - NODE_ENV=production
      - 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=your_secure_password_here
      - N8N_SECURE_COOKIE=true
    ports:
      - "5678:5678"
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      - postgres
    networks:
      - n8n_network
    restart: unless-stopped

  postgres:
    image: postgres:15-alpine
    container_name: n8n_postgres
    environment:
      - POSTGRES_USER=n8n
      - POSTGRES_PASSWORD=your_secure_password_here
      - POSTGRES_DB=n8n
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - n8n_network
    restart: unless-stopped

volumes:
  n8n_data:
  postgres_data:

networks:
  n8n_network:
    driver: bridge

Start the stack:

cd /opt/selfhosted
docker-compose up -d

Step 3: Add Text-to-Speech and Media Processing

Create a separate service for media utilities. Since we're handling text-to-speech, here's a simple Express app that wraps Edge TTS:

cd /opt/selfhosted
mkdir -p tts-service
cd tts-service

Create package.json:

{
  "name": "tts-service",
  "version": "1.0.0",
  "description": "Self-hosted TTS and media service",
  "main": "server.js",
  "dependencies": {
    "express": "^4.18.2",
    "edge-tts": "^0.3.0",
    "fluent-ffmpeg": "^2.1.2",
    "multer": "^1.4.5-lts.1",
    "dotenv": "^16.3.1"
  },
  "scripts": {
    "start": "node server.js"
  }
}

Create server.js:

const express = require('express');
const { execFile } = require('child_process');
const path = require('path');
const fs = require('fs');

const app = express();
const PORT = 3000;

app.use(express.json());

// TTS endpoint
app.post('/tts', async (req, res) => {
  const { text, voice, outputFormat } = req.body;

  if (!text) {
    return res.status(400).json({ error: 'Text is required' });
  }

  const voiceChoice = voice || 'en-US-AriaNeural';
  const format = outputFormat || 'mp3';
  const outputFile = path.join('/tmp', `tts_${Date.now()}.${format}`);

  try {
    execFile('edge-tts', [
      '--text', text,
      '--voice', voiceChoice,
      '--write-media', outputFile
    ], (error, stdout, stderr) => {
      if (error) {
        console.error('TTS Error:', error);
        return res.status(500).json({ error: 'TTS generation failed' });
      }

      res.download(outputFile, `output.${format}`, (err) => {
        if (err) console.error('Download error:', err);
        fs.unlink(outputFile, (unlinkErr) => {
          if (unlinkErr) console.error('Cleanup error:', unlinkErr);
        });
      });
    });
  } catch (err) {
    console.error('Error:', err);
    res.status(500).json({ error: 'Server error' });
  }
});

// Health check
app.get('/health', (req, res) => {
  res.json({ status: 'healthy' });
});

app.listen(PORT, () => {
  console.log(`TTS Service running on port ${PORT}`);
});

Create a Dockerfile:

FROM node:18-alpine

RUN apk add --no-cache \
    python3 \
    ffmpeg \
    curl \
    git

WORKDIR /app

COPY package.json package-lock.json ./
RUN npm install

RUN pip install edge-tts

COPY server.js .

EXPOSE 3000

CMD ["npm", "start"]

Add this service to your docker-compose.yml:

  tts-service:
    build: ./tts-service
    container_name: tts_service
    ports:
      - "3000:3000"
    networks:
      - n8n_network
    restart: unless-stopped
    environment:
      - NODE_ENV=production

Rebuild and restart:

docker-compose up -d --build

Step 4: Set Up Nginx Reverse Proxy

Create /etc/nginx/sites-available/selfhosted.conf:

upstream n8n {
    server localhost:5678;
}

upstream tts {
    server localhost:3000;
}

server {
    listen 80;
    server_name workflow.yourdomain.com tts.yourdomain.com;

    location / {
        return 301 https://$host$request_uri;
    }
}

server {
    listen 443 ssl http2;
    server_name workflow.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/workflow.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/workflow.yourdomain.com/privkey.pem;

    ssl_protocols TLSv1.2 T

Originally published on Automation Insider.

OAuth2 for Beginners: Connecting APIs Without the Pain

Raizan — Thu, 30 Apr 2026 08:00:27 +0000

What You'll Need

n8n Cloud or self-hosted n8n instance
Hetzner VPS or Contabo VPS for self-hosting
A code editor (VS Code recommended)
OAuth2-enabled service account (Google, GitHub, or Spotify)
Basic understanding of HTTP requests and JSON

Understanding OAuth2 Flow
Setting Up Your First OAuth2 Application
Implementing OAuth2 in n8n
Common OAuth2 Patterns and Troubleshooting
Getting Started

Understanding OAuth2 Flow

I remember the first time I tried to integrate with an API that required OAuth2. I expected a simple username and password, and instead got hit with authorization codes, token endpoints, and refresh tokens. It felt like overkill until I realized: OAuth2 isn't designed for your app to hoard user credentials—it's designed so you never touch them.

Here's what actually happens:

User clicks "Connect" → They're redirected to the OAuth provider (Google, GitHub, etc.)
User logs in and grants permission → The provider knows they approved your app
Provider sends back a code → Your app trades this code for an access token
Access token lets you act on their behalf → But only for what they permitted

The genius part? Your app never sees their password. They revoke access whenever they want. And providers can monitor what your app does.

OAuth2 has four main flows, but we're focusing on the Authorization Code Flow—the one you'll use 90% of the time for web apps and automation platforms.

Setting Up Your First OAuth2 Application

Let's walk through registering an OAuth2 app with Google—the most common starting point.

Step 1: Create a Google Cloud Project

Head to Google Cloud Console. Click the project dropdown at the top and select "New Project."

Name it something memorable:

Project Name: My Automation Bot
Organization: (optional)

Hit Create. Google takes 30 seconds to spin it up.

Step 2: Enable the Google Drive API

Once in your project, go to APIs & Services → Library. Search for "Google Drive API" and click Enable.

Do the same for Google Sheets API and Gmail API. We'll use these later.

Step 3: Create OAuth2 Credentials

Navigate to APIs & Services → Credentials. Click + Create Credentials → OAuth Client ID.

Google will ask you to configure a consent screen first. Click Configure Consent Screen:

User Type: External
App name: My Automation Bot
User support email: your-email@gmail.com
Developer contact: your-email@gmail.com

Add scopes for the APIs you enabled. For Gmail, add:

https://www.googleapis.com/auth/gmail.readonly
https://www.googleapis.com/auth/gmail.send

Save and continue.

Now go back to Credentials → + Create Credentials → OAuth Client ID → Web application.

Add Authorized Redirect URIs:

http://localhost:3000/callback
https://yourdomain.com/callback
https://n8n.yourdomain.com/callback

Google generates a Client ID and Client Secret. Save these immediately—you won't see the secret again.

Implementing OAuth2 in n8n

Now let's wire this into n8n. I'll show you both the visual workflow builder and the raw configuration.

Method 1: Using n8n's Built-In OAuth2 Credentials

The easiest path: n8n has pre-configured OAuth2 for major services. Here's how:

Create a new workflow in n8n Cloud or your self-hosted instance
Add a node → Search for "Gmail"
Click Authenticate when prompted
Authorize the pop-up that opens
Done. n8n handles the token exchange automatically.

Under the hood, n8n stores your refresh token encrypted and rotates access tokens before they expire.

Method 2: Custom OAuth2 with HTTP Requests

Sometimes you need to wire up a custom API. Here's the complete flow using n8n's HTTP Request node.

Create a workflow with these nodes in sequence:

Node 1: Webhook (Trigger)

This receives the authorization code from the OAuth provider:

{
  "name": "Webhook",
  "type": "n8n-nodes-base.webhook",
  "typeVersion": 1,
  "position": [100, 200],
  "webhookId": "your-webhook-id",
  "method": "GET",
  "path": "oauth-callback"
}

Node 2: Set Variables

Extract the authorization code from the query parameter:

{
  "name": "Set Authorization Code",
  "type": "n8n-nodes-base.set",
  "typeVersion": 3,
  "position": [400, 200],
  "assignments": [
    {
      "name": "authCode",
      "value": "={{ $query.code }}"
    },
    {
      "name": "state",
      "value": "={{ $query.state }}"
    }
  ]
}

Node 3: Exchange Code for Token

This is the critical step. We POST to the OAuth provider's token endpoint:

{
  "name": "Get Access Token",
  "type": "n8n-nodes-base.httpRequest",
  "typeVersion": 4,
  "position": [700, 200],
  "method": "POST",
  "url": "https://oauth.example.com/token",
  "headers": {
    "Content-Type": "application/x-www-form-urlencoded"
  },
  "sendBody": true,
  "bodyParameters": {
    "parameters": [
      {
        "name": "grant_type",
        "value": "authorization_code"
      },
      {
        "name": "code",
        "value": "={{ $node[\"Set Authorization Code\"].json.authCode }}"
      },
      {
        "name": "client_id",
        "value": "YOUR_CLIENT_ID"
      },
      {
        "name": "client_secret",
        "value": "YOUR_CLIENT_SECRET"
      },
      {
        "name": "redirect_uri",
        "value": "https://n8n.yourdomain.com/webhook/oauth-callback"
      }
    ]
  }
}

Node 4: Store Token Securely

Use n8n's Credential system instead of plaintext storage. Create a new Credential:

Settings → Credentials → + Create:

{
  "credentialType": "oAuth2Api",
  "name": "Custom OAuth2",
  "data": {
    "clientId": "YOUR_CLIENT_ID",
    "clientSecret": "YOUR_CLIENT_SECRET",
    "accessToken": "={{ $node[\"Get Access Token\"].json.access_token }}",
    "refreshToken": "={{ $node[\"Get Access Token\"].json.refresh_token }}",
    "expiresIn": "={{ $node[\"Get Access Token\"].json.expires_in }}"
  }
}

Node 5: Use the Access Token

Now you can make authenticated requests:

{
  "name": "Get User Profile",
  "type": "n8n-nodes-base.httpRequest",
  "typeVersion": 4,
  "position": [1000, 200],
  "method": "GET",
  "url": "https://api.example.com/user/profile",
  "headers": {
    "Authorization": "Bearer {{ $credentials.oAuth2Api.accessToken }}"
  }
}

Handling Token Refresh

Access tokens expire (usually after 1 hour). n8n automatically refreshes them, but here's what happens behind the scenes:

{
  "name": "Refresh Token If Needed",
  "type": "n8n-nodes-base.if",
  "typeVersion": 2,
  "position": [1300, 200],
  "conditions": {
    "nodeVersion": 2,
    "conditions": [
      {
        "id": "condition_0",
        "leftValue": "={{ Date.now() }}",
        "rightValue": "={{ $credentials.oAuth2Api.expiresAt }}",
        "operator": {
          "type": "boolean",
          "properties": {
            "operation": "greaterThan"
          }
        }
      }
    ]
  }
}

If expired, call the refresh endpoint:

{
  "name": "Refresh Access Token",
  "type": "n8n-nodes-base.httpRequest",
  "typeVersion": 4,
  "position": [1300, 400],
  "method": "POST",
  "url": "https://oauth.example.com/token",
  "sendBody": true,
  "bodyParameters": {
    "parameters": [
      {
        "name": "grant_type",
        "value": "refresh_token"
      },
      {
        "name": "refresh_token",
        "value": "={{ $credentials.oAuth2Api.refreshToken }}"
      },
      {
        "name": "client_id",
        "value": "YOUR_CLIENT_ID"
      },
      {
        "name": "client_secret",
        "value": "YOUR_CLIENT_SECRET"
      }
    ]
  }
}

Common OAuth2 Patterns and Troubleshooting

Pattern 1: Multi-Tenant OAuth (SaaS)

If you're building a platform where each user connects their own service:

Store tokens per user in your database with encryption
Add a user ID to the state parameter to match tokens on callback
Use Namecheap to register a domain, then set up a reverse proxy with SSL to handle redirect URIs securely

Here's the state parameter pattern:

{
  "name": "Generate State",
  "type": "n8n-nodes-base.set",
  "typeVersion": 3,
  "assignments": [
    {
      "name": "state",
      "value": "={{ Buffer.from(JSON.stringify({ userId: 123, nonce: Math.random() })).toString('base64') }}"
    }
  ]
}

Pattern 2: Background Token Refresh

For long-running workflows, refresh tokens proactively every 50 minutes:

{
  "name": "Schedule Token Refresh",
  "type": "n8n-nodes-base.cron",
  "typeVersion": 1,
  "triggerTimes": {
    "mode": "everyX",
    "value": 50,
    "unit": "minutes"
  }
}

Common Errors and Fixes

"Invalid redirect URI"

Ensure the redirect URI in Google Console exactly matches what n8n sends
Include protocol (http/https) and port if applicable
No trailing slashes

"Invalid client secret"

You copied it wrong. Go back to Google Console and regenerate.
Check for hidden whitespace.

"Token expired"

Originally published on Automation Insider.

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.

Forem: Raizan

How to Build a YouTube Upload Bot with Node.js and OAuth2

What You'll Need

Table of Contents

Understanding the YouTube Upload Workflow

Setting Up Google OAuth2 Credentials

Building the Core Node.js Bot

Handling OAuth2 Token Refresh

Implementing Video Upload Logic

The Developer Guide to Choosing a Domain Registrar in 2026

What You'll Need

Table of Contents

Why Domain Choice Actually Matters for Developers

The Core Registrar Features You Need

Top Registrars Ranked by Use Case

Best Overall for Developers: Namecheap

Best for Cost-Conscious Builders: Google Domains

Best for Enterprise Scale: Route 53 (AWS)

Best for European Compliance: EasyDNS or Gandi

DNS Management: Where Automation Happens

Pricing Isn't Everything (But API Access Is)

Getting Started

Outsource Your Automation

Automating PDF Report Generation with n8n and Node.js

What You'll Need

Table of Contents

The PDF Generation Challenge

Setting Up Your n8n Workflow

Building a Node.js PDF Service

Connecting n8n to Your PDF Generator

Webhook Fundamentals: What They Are and How to Use Them

What You'll Need

Table of Contents

Understanding Webhooks: The Real-Time Solution

How Webhooks Actually Work

Setting Up Your First Webhook in n8n

Step 1: Create the Webhook Trigger

Step 2: Parse the Incoming Data

Step 3: Route Based on Event Type

Step 4: Send Data to Your Destination

Securing and Validating Webhooks

Implement Signature Verification

Use Webhook Secrets

Common Webhook Patterns and Use Cases

Pattern 1: Real-Time Form Processing

Pattern 2: Multi-Step Integrations

Pattern 3: Error Handling and Retries

Pattern 4: Batching Webhooks

Troubleshooting Webhook Issues

Getting Started

How to Reduce Your SaaS Bill with Self-Hosted Alternatives

What You'll Need

Table of Contents

The Real Cost of SaaS Bloat

Where Self-Hosted Wins

Building Your First Self-Hosted Stack

Step 1: Choose and Configure Your VPS

Step 2: Deploy n8n for Automation

Step 3: Add Text-to-Speech and Media Processing

Step 4: Set Up Nginx Reverse Proxy

OAuth2 for Beginners: Connecting APIs Without the Pain

What You'll Need

Table of Contents

Understanding OAuth2 Flow

Setting Up Your First OAuth2 Application

Step 1: Create a Google Cloud Project

Step 2: Enable the Google Drive API

Step 3: Create OAuth2 Credentials

Implementing OAuth2 in n8n

Method 1: Using n8n's Built-In OAuth2 Credentials

Method 2: Custom OAuth2 with HTTP Requests

Handling Token Refresh

Common OAuth2 Patterns and Troubleshooting

Pattern 1: Multi-Tenant OAuth (SaaS)

Pattern 2: Background Token Refresh

Common Errors and Fixes

Building a Crypto Price Alert Bot with n8n and CoinGecko

What You'll Need

Table of Contents

Understanding the Architecture