Articles on modern web technologies, frameworks and best practices

Web Development

Tutorials and guides on automation with Make, N8N and other tools

Automation

Tips and strategies to grow your digital business

Entrepreneurship

Step-by-step guides to master tools and technologies

Tutorials

Latest trends and innovations in the tech world

Tech News

# n8n Self-Hosted: Complete Guide to Install on VPS (2026)

**n8n self-hosted** is the option chosen by teams who refuse to depend on a SaaS for their critical automations. Zero execution limits, 100% private data, controlled fixed costs.

## Why Self-Host n8n?

### Economic advantage

| Monthly volume | n8n Cloud | n8n Self-hosted |
|---|---|---|
| 2,500 executions | $20/month | ~$6/month (VPS) |
| 10,000 executions | $50/month | ~$6/month |
| 100,000 executions | $400+/month | ~$10/month |

**Over 3 years, the savings reach several thousand dollars** for a team that automates seriously.

### Other advantages

- **No execution limits** — process thousands of operations per hour at no extra cost
- **Reduced latency** if your VPS is in the same region as your APIs
- **Local system connections**: internal databases, file servers, private APIs not exposed on the internet

## Choosing Your VPS for n8n

### Minimum configuration

- **CPU**: 1 vCPU (2 vCPU for AI agents)
- **RAM**: 1 GB (2 GB recommended)
- **Storage**: 20 GB SSD
- **OS**: Ubuntu 22.04 LTS

### Recommended providers

| Provider | Plan | Price/month |
|---|---|---|
| Hetzner | CX21 (2 vCPU, 4 GB) | ~$7 |
| DigitalOcean | Basic 2 GB Droplet | ~$12 |
| Vultr | Cloud Compute | ~$10 |

**Our recommendation**: Hetzner CX21. Excellent performance/price ratio, GDPR-compliant datacenter, 99.9% SLA.

## Step-by-Step Installation

### 1. VPS hardening

```bash
apt update && apt upgrade -y
adduser n8nadmin
usermod -aG sudo n8nadmin
sed -i 's/#PermitRootLogin yes/PermitRootLogin no/' /etc/ssh/sshd_config
systemctl restart sshd
ufw allow OpenSSH && ufw allow 80 && ufw allow 443 && ufw enable
```

### 2. Install Docker

```bash
curl -fsSL https://get.docker.com | sh
usermod -aG docker n8nadmin
systemctl enable docker
```

### 3. Deploy n8n

Follow our [n8n Docker guide](/en/blog/n8n-docker-complete-installation-guide-2026) for the docker-compose.yml file and full HTTPS configuration.

### 4. Automatic monitoring

```bash
#!/bin/bash
STATUS=$(curl -s -o /dev/null -w "%{http_code}" https://n8n.your-domain.com/healthz)
if [ "$STATUS" != "200" ]; then
    cd ~/n8n && docker compose restart n8n
    curl -X POST "https://hooks.slack.com/..." -d '{"text":"⚠️ n8n restarted"}'
fi
```

Cron: `*/5 * * * * /bin/bash ~/healthcheck-n8n.sh`

## n8n Self-Hosted vs Cloud: 2026 Verdict

**Choose self-hosted if**: >2,500 executions/month, sensitive data, technical team, controlled costs.

**Choose cloud if**: beginner, low volume, no infrastructure to manage.

Our [BOVO Digital team](/en/expert-automatisation) can deploy and configure your n8n self-hosted instance with training included.

Complete guide to deploying n8n self-hosted on a VPS in 2026. VPS choice, hardening, Docker, HTTPS, monitoring. Unlimited workflows, private data.

n8n Self-Hosted: Complete Installation on Ubuntu VPS (2026)

n8n Self-Hosted: Complete Guide to Install on VPS (2026)

# n8n Templates: The 10 Best Ready-to-Use Automation Workflows

**n8n templates** are pre-built workflows you can import and adapt in minutes. The official library lists several thousand — but 90% of business needs are covered by about twenty essential patterns.

## Where to Find n8n Templates

- **Official library**: n8n.io/workflows — 900+ templates by use case
- **In the n8n interface**: Menu > Templates
- **GitHub Community**: Hundreds of community-shared workflows

## The 10 Essential n8n Templates

### 1. Slack notification on new Gmail email

**Use case**: Alert the team in real time when an important email arrives.
**Nodes**: Gmail Trigger → Filter → Slack | **Setup time**: 10 minutes

### 2. CRM ↔ Google Sheets sync

**Use case**: Auto-export new CRM contacts (HubSpot, Pipedrive) to Google Sheets.
**Nodes**: CRM Trigger → Transform → Google Sheets | **Setup time**: 20 minutes

### 3. AI email reply agent

**Use case**: Classify incoming emails and generate a draft reply with GPT-4.
**Nodes**: Gmail Trigger → AI Agent → Gmail (Send Draft)
**Why it's useful**: Reduces repetitive email processing by 60%.
**Setup time**: 30 minutes

### 4. Automatic social media publishing

**Use case**: Publish approved Google Doc content to LinkedIn, Twitter/X and Instagram.
**Nodes**: Google Sheets Trigger → OpenAI → LinkedIn + Twitter + Instagram | **Setup time**: 45 minutes

### 5. B2B lead scraping and enrichment

**Use case**: Gather companies, enrich them (email, revenue), push to CRM.
**Nodes**: HTTP Request → AI Extraction → HubSpot/Airtable
**Why it's useful**: Replaces hours of manual prospecting. | **Setup time**: 1h

### 6. Website monitoring with alert

**Use case**: Check every 5 minutes if your site responds, alert on Slack if timeout.
**Nodes**: Schedule Trigger → HTTP Request → IF → Slack | **Setup time**: 15 minutes

### 7. WhatsApp AI chatbot

**Use case**: Automatically reply to WhatsApp Business messages with Claude or GPT.
**Nodes**: WhatsApp Trigger → AI Agent → WhatsApp
**Why it's useful**: 24/7 customer support without a team. | **Setup time**: 2h

### 8. Automated weekly report

**Use case**: Aggregate Google Analytics, Stripe, Notion data — send a report every Monday.
**Nodes**: Schedule Trigger → Multiple APIs → Merge → HTML Template → Email | **Setup time**: 2h

### 9. Automated client onboarding

**Use case**: Trigger welcome emails + account creation + Slack notification when a Stripe payment arrives.
**Nodes**: Stripe Trigger → Create User → Email Sequence → Slack | **Setup time**: 1h30

### 10. Multi-database synchronization

**Use case**: Keep two databases in sync (Airtable ↔ Notion, MySQL ↔ Sheets).
**Nodes**: Database Trigger → Compare → Upsert → Database | **Setup time**: 1h30

## How to Adapt an n8n Template

1. **Import the template** from the library
2. **Replace credentials** in each node
3. **Adapt filters** to your business logic
4. **Test manually** with real data before activating
5. **Set up error alerts**: Error Trigger node → Slack if a workflow fails

For workflows beyond standard templates, our team builds [custom n8n automations](/en/expert-automatisation) tailored to your stack.

Discover the 10 best n8n templates to automate your business. Slack, CRM, emails, WhatsApp, reports — ready in a few clicks.

n8n Templates: The 10 Best Ready-to-Use Workflows (2026)

n8n Templates: The 10 Best Ready-to-Use Automation Workflows

# n8n Docker: Complete Installation and Configuration Guide (2026)

**n8n Docker** is the deployment method preferred by teams who want total control over their data. In 15 minutes, you can have your own n8n instance ready to automate your business processes — without paying the cloud subscription.

## Why Install n8n with Docker?

- **Complete isolation**: n8n runs in its own container with no system conflicts
- **One-command updates**: `docker pull n8nio/n8n:latest`
- **Persistent data**: Docker volumes preserve your workflows across restarts
- **Reproducible**: The same `docker-compose.yml` works on any server
- **Free**: n8n Community Edition is open source with no workflow limits

## Prerequisites

- A Linux VPS (Ubuntu 22.04 recommended) with at least 1 GB RAM
- Docker Engine 24.x or higher
- Docker Compose V2
- A domain name pointed to your server (for HTTPS)

## Installing n8n with Docker Compose

### Step 1: Create the directory structure

```bash
mkdir -p ~/n8n/data
cd ~/n8n
```

### Step 2: Create docker-compose.yml

```yaml
version: '3.8'

services:
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - N8N_HOST=n8n.your-domain.com
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=https://n8n.your-domain.com/
      - GENERIC_TIMEZONE=Europe/London
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=your-strong-password
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n_user
      - DB_POSTGRESDB_PASSWORD=your-db-password
    volumes:
      - ./data:/home/node/.n8n
    depends_on:
      - postgres

  postgres:
    image: postgres:16-alpine
    container_name: n8n_postgres
    restart: unless-stopped
    environment:
      - POSTGRES_DB=n8n
      - POSTGRES_USER=n8n_user
      - POSTGRES_PASSWORD=your-db-password
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:
```

### Step 3: Start n8n

```bash
docker compose up -d
docker compose ps
docker compose logs n8n
```

## HTTPS Configuration with Nginx

```nginx
server {
    listen 443 ssl;
    server_name n8n.your-domain.com;

    ssl_certificate /etc/letsencrypt/live/n8n.your-domain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/n8n.your-domain.com/privkey.pem;

    location / {
        proxy_pass http://localhost:5678;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_buffering off;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}
```

Get your SSL certificate: `certbot --nginx -d n8n.your-domain.com`

## Essential Environment Variables

| Variable | Description | Example |
|---|---|---|
| N8N_HOST | Your instance domain | n8n.mydomain.com |
| WEBHOOK_URL | Full URL for webhooks | https://n8n.mydomain.com/ |
| GENERIC_TIMEZONE | Execution timezone | Europe/London |
| N8N_ENCRYPTION_KEY | Credential encryption key | Generate with openssl rand -hex 32 |

## Updating n8n

```bash
cd ~/n8n
docker compose pull
docker compose up -d
```

## Automated Backups

```bash
#!/bin/bash
DATE=$(date +%Y%m%d)
docker exec n8n_postgres pg_dump -U n8n_user n8n > ~/backups/n8n_backup_$DATE.sql
find ~/backups -name "n8n_backup_*.sql" -mtime +30 -delete
```

Add to cron: `0 3 * * * /bin/bash ~/backup-n8n.sh`

## Conclusion

You now have an n8n Docker instance running with HTTPS and automated backups. To build **autonomous AI agents** on your n8n instance, check out our [n8n & Make automation service](/en/expert-automatisation).

Complete guide to installing n8n with Docker in 2026. Docker Compose setup, HTTPS Nginx, PostgreSQL and automated backups. Step-by-step tutorial.

n8n Docker: Complete Installation with Docker Compose (2026)

n8n Docker: Complete Installation and Configuration Guide (2026)

## Before we start: why this setup changes the rules

On April 2, 2026, Google launched Gemma 4 under the Apache 2.0 license. This isn't a demo model or a bridled model to attract developers. It's a frontier-level model — comparable to Claude Haiku and GPT-4o mini — available in 4 sizes (2B, 8B, 16B, 31B) and usable **for free, locally, with no data sent externally**.

Combined with Ollama (the local model runtime that exploded in popularity in 2025) and connected to n8n, this setup gives you:

- **Zero inference cost** — no paid API
- **Absolute privacy** — your data never leaves your machine
- **Unlimited throughput** — no rate limits, no quotas
- **Native tool use** — Gemma 4 natively supports tool calls (function calling) for your n8n agents

Here's the step-by-step tutorial. Duration: 20 minutes if you've never installed Ollama.

---

## Prerequisites

**Minimum hardware:**
- For Gemma 4 2B: 8 GB RAM (runs even on a 2022 laptop without GPU)
- For Gemma 4 8B: 16 GB RAM or a dedicated GPU (NVIDIA 8 GB VRAM)
- For Gemma 4 16B and 31B: dedicated GPU recommended (16-24 GB VRAM)

**Software:**
- macOS, Linux or Windows 10/11
- n8n installed locally or in the cloud (n8n.cloud, VPS with Docker)
- 5 GB free disk space for the 2B model (15 GB for 8B)

If you don't have n8n yet, start with our [tutorial to create your first AI agent with n8n](/blog/tutoriel-creez-premier-agent-ia-autonome-n8n) — it walks you from installation to your first workflow.

---

## Step 1: Install Ollama

Ollama is a runtime that simplifies running local LLMs. It handles downloading, quantization and the local API automatically.

**On macOS / Linux:**
```bash
curl -fsSL https://ollama.com/install.sh | sh
```

**On Windows:**
Download the installer from [ollama.com](https://ollama.com) and run it. Ollama installs as a Windows service and starts automatically.

**Verify installation:**
```bash
ollama --version
# → ollama version 0.3.x or higher
```

---

## Step 2: Download Gemma 4

```bash
# 2B version — recommended for machines without GPU
ollama pull gemma4:2b

# 8B version — better quality, requires 16 GB RAM or GPU
ollama pull gemma4:8b
```

Download takes 5 to 15 minutes depending on your connection (2-5 GB depending on version).

---

## Step 3: Test Gemma 4 locally

Before integrating it into n8n, verify the model works correctly:

```bash
ollama run gemma4:2b
```

You'll enter an interactive chat. Type a few questions to test response quality. To exit: `/bye`

**Tool use test (function calling):**
```bash
curl http://localhost:11434/api/chat -d '{
  "model": "gemma4:2b",
  "messages": [{ "role": "user", "content": "What is the weather in Paris?" }],
  "tools": [{
    "type": "function",
    "function": {
      "name": "get_weather",
      "description": "Gets weather for a city",
      "parameters": {
        "type": "object",
        "properties": { "city": { "type": "string" } },
        "required": ["city"]
      }
    }
  }]
}'
```

Gemma 4 should return a structured tool call — proof that function calling works.

---

## Step 4: Connect Gemma 4 to n8n

Ollama exposes an OpenAI-compatible REST API at `http://localhost:11434`. That's what we'll use in n8n.

**If n8n runs locally (same machine as Ollama):**

In your n8n workflow, add an **HTTP Request** node with this configuration:

- **Method:** POST
- **URL:** `http://localhost:11434/api/chat`
- **Body (JSON):**
```json
{
  "model": "gemma4:2b",
  "messages": [
    { "role": "system", "content": "You are a helpful and precise assistant." },
    { "role": "user", "content": "{{ $json.message }}" }
  ],
  "stream": false
}
```

**If n8n runs in the cloud or on a VPS:**

You need to expose Ollama on the network. On the server hosting Ollama:

```bash
# Launch Ollama exposing on all interfaces
OLLAMA_HOST=0.0.0.0:11434 ollama serve
```

Then in n8n, replace `localhost` with your Ollama server's IP.

**Alternative — use n8n's OpenAI node with the Ollama API:**

n8n includes a "Chat Model (OpenAI)" node that can point to any OpenAI-compatible API. Configure an "OpenAI API" credential with:
- **Base URL:** `http://localhost:11434/v1`
- **API Key:** `ollama` (any value, Ollama doesn't require one)
- **Model:** `gemma4:2b`

---

## Step 5: First agent workflow with Gemma 4

Here's a concrete example: an agent that summarizes incoming emails and classifies them by priority.

**Workflow structure:**

1. **Trigger**: Gmail / IMAP — triggered on each new email
2. **HTTP Request** → Ollama/Gemma 4 with the prompt:
   `"Analyze this email and return a JSON with: {subject: string, priority: 'high'|'medium'|'low', summary: string (max 2 sentences), action_required: boolean}. Email: {{ $json.body }}"`
3. **JSON Parse** → Extracts fields from the returned JSON
4. **Switch** → Branch on priority
5. **Slack / Email** → Notification for high-priority emails only

This workflow runs locally, sorts your emails without any data going to OpenAI, and costs **€0/month**.

To go further with n8n agents, check our guide on [deploying AI MCP agents in 20 minutes](/blog/tutoriel-deployer-agent-ia-mcp-serveur-20-minutes).

---

## Performance and limitations to know

**What Gemma 4 2B does well:**
- Classification, summarization, structured information extraction
- Responses in 20+ languages (supports 140 languages)
- Reasoning on contexts up to 250,000 tokens

**What Gemma 4 2B does less well:**
- Complex mathematical reasoning (prefer 8B or 16B)
- Complex multi-file code (8B is significantly better)
- Speed: ~15-30 tokens/second on CPU, ~80-150 tokens/second on GPU

**For production:** Gemma 4 2B is perfect for prototyping and simple-to-medium use cases. For production agents with high volumes or complex cases, we recommend either the 8B model on GPU, or a hybrid local + cloud architecture that we regularly design at BOVO Digital.

---

## From demo to production

This setup is ideal for rapid prototyping without budget. When you've validated your use case and want to scale — with high availability, persistent memory, RAG on your documents, and monitoring — that's where a production architecture comes in.

Read our article on [n8n vs Make](/blog/n8n-vs-make-comparatif-complet-automatisation-2026) to understand how to choose your automation stack based on volume and context.

> **You've validated your use case locally and want to move to production?**
>
> [Let's build the robust version together →](/#contact)

Discover our [AI automation and intelligent agent services](/expert-automatisation) — and [William Aklamavo's](/william-merveille-aklamavo) profile, who delivers these production architectures.

Complete guide to install Gemma 4 with Ollama and connect it to n8n. Build your first 100% local, free, data-private AI agent in 20 minutes.

Tutorial: Gemma 4 + Ollama + n8n — Free and Private Local AI Agent (2026)

Tutorial: Gemma 4 Locally with Ollama + n8n — Your First 100% Free and Private AI Agent

# Tutorial: Deploy an AI Agent with MCP on Your Server in 20 Minutes

The **Model Context Protocol (MCP)** is becoming the universal standard for connecting AI to your tools, databases, and services. Adopted by OpenAI, Anthropic, Google, and all major AI agent frameworks, MCP is the missing piece that transforms a simple chatbot into an assistant capable of **acting** in the real world.

In this tutorial, we'll build an **MCP server** that gives Claude (or any LLM) the ability to read and modify your files, query your database, and trigger actions in your systems.

## What is MCP?

Think of MCP as a **universal adapter** for AI:

*   **Without MCP**: Your AI can only read text and generate text. It's isolated from the world.
*   **With MCP**: Your AI can read your database, create files, send emails, trigger deployments, modify Jira tickets, etc.

### MCP Architecture in 30 Seconds

```
[User] → [MCP Client (e.g., Claude)] → [MCP Server] → [Your tools/APIs/DB]
```

The **MCP Server** exposes a collection of tools that the LLM can call. The process:

1. **Discovery**: The MCP client connects to the server and discovers available tools.
2. **Decision**: The LLM analyzes the user request and chooses which tool to use.
3. **Invocation**: The MCP client executes the tool with parameters generated by the LLM.
4. **Execution**: The MCP server processes the request (DB access, API, files...).
5. **Response**: The result is returned to the LLM, which integrates it into its response.

## Prerequisites

*   **Node.js 20+** installed
*   **npm** or **pnpm**
*   A code editor (VS Code recommended)
*   (Optional) A Claude API key to test full integration

---

## Step 1: Initialize the Project

```bash
mkdir my-mcp-server
cd my-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node tsx
```

## Step 2: Create the MCP Server

Create `src/server.ts`:

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import * as fs from "fs/promises";
import * as path from "path";

const server = new McpServer({
  name: "my-mcp-server",
  version: "1.0.0",
});

// Tool 1: List files in a directory
server.tool(
  "list_files",
  "Lists files in a given directory",
  {
    directory: z.string().describe("Path of the directory to list"),
  },
  async ({ directory }) => {
    const files = await fs.readdir(directory, { withFileTypes: true });
    const result = files.map(f => ({
      name: f.name,
      type: f.isDirectory() ? "directory" : "file"
    }));
    return {
      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
    };
  }
);

// Tool 2: Read file content
server.tool(
  "read_file",
  "Reads and returns the content of a file",
  {
    filepath: z.string().describe("Full path of the file"),
  },
  async ({ filepath }) => {
    const content = await fs.readFile(filepath, "utf-8");
    return {
      content: [{ type: "text", text: content }]
    };
  }
);

// Tool 3: Write to a file
server.tool(
  "write_file",
  "Writes content to a file (creates or overwrites)",
  {
    filepath: z.string().describe("File path"),
    content: z.string().describe("Content to write"),
  },
  async ({ filepath, content }) => {
    await fs.mkdir(path.dirname(filepath), { recursive: true });
    await fs.writeFile(filepath, content, "utf-8");
    return {
      content: [{ type: "text", text: "File written successfully." }]
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);
```

## Step 3: Test Locally

```bash
npx tsx src/server.ts
```

## Step 4: Integrate with Claude Desktop

Add your server to the Claude Desktop configuration:

```json
{
  "mcpServers": {
    "my-server": {
      "command": "npx",
        "args": ["tsx", "/path/to/my-mcp-server/src/server.ts"]
    }
  }
}
```

Restart Claude Desktop. You'll now see a 🔧 icon indicating your MCP tools are available.

## Step 5: Integrate with n8n

If you use **n8n 2.0+**, MCP support is native:

1. In n8n, add an **"MCP Client"** node
2. Point to your MCP server (via stdio or HTTP)
3. The AI agent in n8n can now use your MCP tools as native tools

This is the ultimate combination: **n8n for orchestration** + **MCP for tool access** + **LLM for reasoning**.

## Security: Golden Rules

1. **Principle of Least Privilege**: Only grant access to strictly necessary folders and APIs
2. **Input Validation**: Use **Zod** to rigorously validate all inputs
3. **Sandbox**: Run MCP servers in Docker containers in production
4. **Audit Logs**: Record every tool call with parameters and results

## Conclusion

MCP is the missing piece that transforms generative AI into agentic AI. In 20 minutes, you've created a server that gives Claude the ability to read your files, write code, and interact with your APIs.

**New to AI agents and want to start simpler?** Before diving into MCP, master the fundamentals with n8n — no coding required.
👉 [Tutorial: Build Your First Autonomous AI Agent with n8n in 20 Minutes (No Code)](/en/blog/tutorial-create-first-autonomous-ai-agent-n8n)

---

**Want a custom MCP server for your business?** At BOVO Digital, we build personalized MCP servers that connect your AI to all your internal systems. Automation + Intelligence = Productivity.

Step-by-step guide to creating an MCP (Model Context Protocol) server, connecting it to Claude or n8n, and giving your AI the ability to act in the real world.

MCP Tutorial: Create a Connected AI Agent in 20 Minutes

Tutorial: Deploy an AI Agent with MCP on Your Server in 20 Minutes

# Tutorial: Build a WhatsApp Chatbot with n8n and Claude in 30 Minutes

WhatsApp has **2.7 billion active users**. Here's how to build a **functional WhatsApp chatbot** with **n8n 2.0** and **Claude**.

## Architecture

```
WhatsApp Business API
      ↓ webhook
    n8n 2.0
      ├── Receive message
      ├── AI Agent (Claude)
      │   ├── Memory (Redis/Supabase)
      │   └── Tools (CRM, FAQ)
      └── Send response
      ↓
WhatsApp (user)
```

## Prerequisites

*   **n8n** v2.0+
*   **WhatsApp Business API** account
*   **Anthropic** API key
*   (Optional) **Supabase** for memory

---

## Step 1: WhatsApp Webhook

1. Create an n8n workflow
2. Add a **"Webhook"** node (POST)
3. Configure the URL in **Meta Business Platform**
4. Events: `messages`, `message_status`

## Step 2: Parse the Message

```javascript
const body = $input.first().json.body;
const message = body.entry?.[0]?.changes?.[0]?.value?.messages?.[0];

return [{
  json: {
    from: message?.from,
    text: message?.text?.body,
    type: message?.type,
    messageId: message?.id
  }
}];
```

## Step 3: AI Agent

1. Add an **"AI Agent"** node
2. Connect **"Anthropic Chat Model"** (Claude Sonnet or Opus)
3. System Prompt: friendly assistant, concise, able to escalate

## Step 4: Memory

1. **"Window Buffer Memory"** node
2. **Session ID**: WhatsApp number (`{{ $json.from }}`)
3. **Window Size**: 10 messages

## Step 5: Send Response

```javascript
{
  "method": "POST",
  "url": "https://graph.facebook.com/v18.0/PHONE_ID/messages",
  "headers": {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json"
  },
  "body": {
    "messaging_product": "whatsapp",
    "to": "{{ $json.from }}",
    "type": "text",
    "text": { "body": "{{ $json.output }}" }
  }
}
```

## Step 6: Human Escalation

*   If response contains "transfer" → Slack notification to support
*   If negative sentiment → Automatic escalation

## Rate Limiting Anti-Ban

*   **Delay**: min 1 second between messages
*   **Max**: 30 messages/minute
*   **Window**: 24h after last client message

## Result

```
Webhook → Parser → AI Agent → Condition → Send WhatsApp
```

Your chatbot responds intelligently, remembers context, and escalates when needed.

---

**Want a professional WhatsApp chatbot?** At BOVO Digital, we build custom chatbots with conversational AI.

Step-by-step guide to building an intelligent WhatsApp chatbot with n8n 2.0 and Claude. Webhook, memory, human escalation.

Tutorial: WhatsApp Chatbot with n8n and Claude in 30 Minutes

Tutorial: Build a WhatsApp Chatbot with n8n and Claude in 30 Minutes

# Tutorial: Create Your First Autonomous AI Agent with n8n (Complete Guide 2025)

You've heard of AI agents and want to build your own? You are in the right place. With the recent updates to **n8n** in November 2025, creating an autonomous agent has become accessible to everyone, without needing to be a Python expert.

In this tutorial, we will build a **"Tech Watch Agent"**.
**Its mission:** Search for the latest news on a given topic, analyze it, and send us a concise summary on Slack or via Email.

## Prerequisites
*   An **n8n** account (Cloud or Self-hosted version 1.65+).
*   An **OpenAI** API key (or Anthropic).
*   (Optional) A **Tavily** or **SerpApi** API key for web search (Tavily offers a generous free version).

---

## Step 1: Create the Workflow and Add the AI Agent Node

1.  Open your n8n editor and create a new workflow.
2.  Add a trigger node. For this test, use the **"On Chat Heading"** node (if you want to chat with it) or **"Manual Trigger"**. Let's say **"Manual Trigger"** to start.
3.  Search for and add the **"AI Agent"** node.

This is the heart of our system. Double-click on it to configure it.

## Step 2: Configure the Brain (The Model)

The agent needs a brain.
1.  In the AI Agent node inputs, you will see a connector for "Model".
2.  Add an **"OpenAI Chat Model"** node and connect it to the agent's "Model" input.
3.  Configure your OpenAI credentials.
4.  Select the model: **GPT-4o** or **GPT-4o-mini** (faster and cheaper, often sufficient).

## Step 3: Give Tools to the Agent

This is where the magic happens. Without tools, AI can only talk. With tools, it can act.
1.  In the AI Agent node inputs, locate the "Tools" connector.
2.  We will add a search tool. Search for the **"Tavily Search"** node (or an "HTTP Request" tool configured for a search API if you prefer). Connect it to the "Tools" input.
3.  (Optional) Add a **"Calculator"** tool if you want it to be able to do math, or a **"Wikipedia"** tool.

*Note: You can connect multiple tools to the same "Tools" connector. The agent will choose the one it needs.*

## Step 4: Define the System Prompt

Go back to the **AI Agent** node configuration.
In the "System Message" or "Instructions" field, give it its personality and rules:

> "You are an expert technology research assistant.
> Your goal is to find precise and recent information on the subject requested by the user.
> Use the search tool to find facts.
> Only cite verified information.
> At the end, write a structured summary in English with bullet points."

## Step 5: Test the Agent

1.  Add an **"Edit Fields"** (Set) node before the agent to define your question (if you are not using the Chat Trigger). Create a field `chatInput` with the value: *"What are the latest Next.js features released this week?"*.
2.  Execute the workflow.

**What will happen (watch the execution view):**
1.  The agent receives the question.
2.  It "thinks" and sees that it doesn't know the answer by heart because it is recent.
3.  It decides to use the **Tavily Search** tool.
4.  It generates an optimized search query.
5.  Tavily returns the results.
6.  The agent reads the results, synthesizes them, and generates the final answer.

## Step 6: Connect to Output (Slack/Email)

Once the agent has generated its response (output of the AI Agent node), you can add a **"Slack"** or **"Gmail"** node.
Use the agent's output variable (usually `output`) as the message content.

## Conclusion and Going Further

Congratulations! You have just created an autonomous agent. It's not just a script that searches Google; it's an AI that *understood* your need and *used* a tool to answer it.

To go further:
*   Add a **Memory** (Window Buffer Memory) to have a continuous conversation.
*   Give it more powerful tools: access to your Notion, your Google Calendar, or the ability to send HTTP requests to your own APIs.

Automation with n8n is now limited only by your imagination.

Step-by-step n8n tutorial: create an autonomous AI agent that researches the web and writes summaries automatically. No Python required. Works with GPT-4o & Claude.

n8n AI Agent Tutorial 2026: Build Your First Agent in 20 Minutes (Free)

n8n AI Agent Tutorial: Build Your First Autonomous Agent in 20 Minutes (2026)

# How to Create a Mobile App in 2026: Complete Guide for Entrepreneurs

**Creating a mobile app** has become more accessible than in 2020, but also more complex — with the explosion of no-code, AI-assisted development, and cross-platform frameworks like Flutter. This guide gives you a clear, honest overview of every step.

## Why Create a Mobile App in 2026?

- **89% of mobile time** is spent in apps
- **70% of e-commerce purchases** start on mobile
- A mobile app's conversion rate is **3x higher** than a mobile website

## Step 1: Define Your App

Before writing a single line of code, answer these questions:

**What problem does it solve?** Validate with 10-15 user interviews before investing.

**What are the MVP features?** List everything and keep only the 20% that delivers 80% of the value.

## Step 2: Choose the Right Technology

### Flutter (our 2026 recommendation)

**For**: Single codebase for iOS + Android, near-native performance, maintained by Google
**Against**: Fewer native libraries than Swift/Kotlin

**When to choose**: The vast majority of business apps, e-commerce, marketplace, B2B tools

### React Native

**For**: Reuses React skills, massive community
**Against**: Lower performance than Flutter for complex animations

### Native (Swift / Kotlin)

**For**: Maximum performance, full native API access
**Against**: Double budget, double maintenance

### No-code (FlutterFlow, Bubble)

**For**: Fast, accessible without a developer
**Against**: Vendor lock-in, hard to evolve beyond basic features

**Our recommendation: Flutter.** Best performance/cost/maintainability balance.

## Step 3: Estimate the Budget

| App type | Duration | Estimated budget |
|---|---|---|
| Simple MVP (5-7 screens) | 4-6 weeks | $3,500 – $9,000 |
| Business app (15-25 screens) | 2-4 months | $9,000 – $28,000 |
| Complex app (marketplace, AI) | 4-8 months | $28,000 – $90,000 |

**Budget-increasing factors**: in-app payments, advanced push notifications, offline mode, AI integration, admin dashboard.

## Step 4: The Development Process

1. **Discovery (1-2 weeks)**: Wireframes, user validation, technical specs
2. **UI/UX Design (1-2 weeks)**: Style guide, Figma screens, clickable prototype
3. **Development (4-12 weeks)**: Iterative sprints, weekly demos
4. **QA Testing (1-2 weeks)**: Functional, load, real user tests
5. **Publishing**: App Store (1-7 days) + Google Play (1-3 days)
6. **Maintenance**: iOS/Android updates, bug fixes, new features

## Step 5: Publishing on the Stores

**App Store (Apple)**
- Developer account: $99/year
- Review time: 1-7 days
- Strict rules on privacy and payments

**Google Play**
- Developer account: $25 one-time
- Review time: 1-3 days

**Prepare**: Screenshots (6+ sizes), ASO-optimized description, mandatory privacy policy.

## Mistakes to Avoid

**Mistake #1: Wanting everything in v1.** Focus on solving one problem well.

**Mistake #2: Not testing with real users.** Test from the wireframe stage, not after development.

**Mistake #3: Neglecting maintenance.** An unmaintained app loses 30% of its users/year.

**Mistake #4: Choosing no-code to save money.** No-code can cost 3x more when you outgrow its limits.

## Conclusion

1. **Validate your idea** with 10 user interviews
2. **Write your MVP** on one page (problem + 3 key features)
3. **Get 3 quotes** from agencies with a Flutter portfolio
4. **Start small** — 6 perfect screens beat 30 broken ones

BOVO Digital builds [Flutter mobile apps](/en/expert-mobile) for iOS and Android, from MVP to enterprise. Free quote within 24h.

Complete guide to creating a mobile app in 2026. Technology choice (Flutter, React Native, no-code), realistic budget, key steps and mistakes to avoid.

How to Create a Mobile App in 2026: Entrepreneur's Complete Guide

How to Create a Mobile App in 2026: Complete Guide for Entrepreneurs

# n8n vs Zapier: Complete Comparison 2026 — Which One to Choose?

**n8n vs Zapier** is the central debate in no-code/low-code automation in 2026. Both tools connect apps and automate tasks, but their philosophies, pricing, and capabilities differ significantly.

## Overview

| Criterion | n8n | Zapier |
|---|---|---|
| **Type** | Open source + Cloud | Proprietary SaaS |
| **Price** | Free (self-hosted) / $20/mo | $19.99 to $799/mo |
| **Learning curve** | Moderate | Low |
| **Integrations** | 400+ nodes + custom HTTP | 6,000+ apps |
| **Native AI agents** | Yes (advanced) | Partial |
| **Self-hosting** | Yes | No |
| **Execution limits** | Unlimited (self-hosted) | Based on tasks/month |

## Pricing: n8n's Advantage

### n8n Pricing 2026

- **Self-hosted Community**: 100% free, unlimited workflows
- **n8n Cloud Starter**: $20/mo — 2,500 active executions
- **n8n Cloud Pro**: $50/mo — 10,000 active executions

### Zapier Pricing 2026

- **Free**: 100 tasks/month, 5 Zaps
- **Starter**: $19.99/mo — 750 tasks/month
- **Professional**: $49/mo — 2,000 tasks/month
- **Company**: $799/mo — 50,000 tasks/month

**Pricing verdict**: n8n self-hosted is unbeatable on cost. Zapier gets expensive fast above 2,000 tasks/month.

## Integrations: Zapier's Advantage

Zapier offers **6,000+ native integrations** vs **400+ nodes** for n8n. But n8n compensates with an HTTP Request node that connects to any REST API and community nodes.

In practice, if a tool has an API, n8n can connect to it.

## AI Agents: n8n's Advantage

In 2026, n8n's AI agents are significantly more powerful:

- **AI Agent Node**: Multi-step reasoning with state management
- **Persistent memory**: Agent remembers previous conversations
- **Built-in RAG**: Native connection to vector stores (Pinecone, Qdrant)
- **Human-in-the-loop**: Human validation within agent flows

## Ease of Use: Zapier's Advantage

Zapier was built for non-technical users from day one. n8n has a learning curve of **2-4 hours** for a motivated non-developer.

## When to Choose n8n?

- High execution volumes (>2,000/month)
- Sophisticated AI agents
- Sensitive data (GDPR, healthcare, finance) → self-hosting
- Controlled long-term costs

## When to Choose Zapier?

- You're starting and want to automate in 30 minutes
- Low volume (<500/month)
- Very specific integration absent from n8n

## Conclusion

> Zapier is for getting started fast. n8n is for going far.

For a startup or SMB automating seriously, **n8n is the best investment in 2026**. Our team builds [custom n8n automations](/en/expert-automatisation) — free audit, full integration.

Honest n8n vs Zapier comparison in 2026. Pricing, integrations, AI agents, self-hosting — everything to choose the right automation tool for your team.