HTTP Request and Postgres integration

System Architecture Two integrated N8N workflows providing automated US stock portfolio management through Telegram: FLOW 1: Conversational Portfolio Manager Telegram bot for interactive portfolio management PDF upload & analysis via LlamaIndex Cloud API Natural language portfolio updates via GPT-4.1-mini Real-time user registration and data management FLOW 2: Automated Weekly Reports Schedule-triggered weekly analysis (every 7 days) Perplexity AI sonar-deep-research for market analysis Professional PDF report generation via PDFco Automatic Telegram delivery to all registered users

Description This workflow is designed for B2B/SaaS teams who want to secure renewals before it’s too late. It runs every day, identifies all accounts whose licenses are up for renewal in J–30, enriches them with CRM, product usage and support data, computes an internal churn risk level, and then triggers the appropriate playbook: HIGH risk** → full escalation (tasks, alerts, emails) MEDIUM risk** → proactive follow-up by Customer Success LOW risk** → light renewal touchpoint / monitoring Everything is logged into a database table so that you can build dashboards, run analysis, or plug additional automations on top. How it works Daily detection (J–30 renewals) A scheduled trigger runs every morning and queries your database (Postgres / Supabase) to fetch all active subscriptions expiring in 30 days. Each row includes the account identifier, name, renewal date and basic commercial data. Data enrichment across tools For each account, the workflow calls several business systems to collect context: HubSpot → engagement history Salesforce → account profile and segment Pipedrive → deal activities and associated products Analytics API → product feature usage and activity trends Zendesk → recent support tickets and potential friction signals All of this is merged into a single, unified item. Churn scoring & routing An internal scoring step evaluates the risk for each account based on multiple signals (engagement, usage, support, timing). The workflow then categorizes each account into one of three risk levels: HIGH – strong churn signals → needs immediate attention MEDIUM – some warning signs → needs proactive follow-up LOW – looks healthy → light renewal reminder A Switch node routes each account to the relevant playbook. Automated playbooks 🔴 HIGH risk Create a Trello card on a dedicated “High-Risk Renewals” board/list Create a Jira ticket for the CS / AM team Send a Slack alert in a designated channel Send a detailed email to the CSM and/or account manager 🟠 MEDIUM risk Create a Trello card in a “Renewals – Follow-up” list Send a contextual email to the CSM to recommend a proactive check-in 🟢 LOW risk Send a soft renewal email / internal note to keep the account on the radar Logging & daily reporting For every processed account, the workflow prepares a structured log record (account, renewal date, risk level, basic context). A Postgres node is used to insert the data into a churn_logs table. At the end of each run, all processed accounts are aggregated and a daily summary email is sent (for example to the Customer Success leadership team), listing the renewals and their risk levels. Requirements Database A table named churn_logs (or equivalent) to store workflow decisions and history. Example fields: account_id, account_name, end_date, riskScore, riskLevel, playbook, trello_link, jira_link, timestamp. External APIs HubSpot (engagement data) Salesforce (account profile) Pipedrive (deals & products) Zendesk (support tickets) Optional: product analytics API for usage metrics Communication & task tools Gmail (emails to CSM / AM / summary recipients) Slack (alert channel for high-risk cases) Trello (task creation for CS follow-up) Jira (escalation tickets for high-risk renewals) Configuration variables Thresholds are configured in the Init config & thresholds node: days_before_renewal churn_threshold_high churn_threshold_medium These parameters let you adapt the detection window and risk sensitivity to your own business rules. Typical use cases Customer Success teams who want a daily churn watchlist without exporting spreadsheets. RevOps teams looking to standardize renewal playbooks across tools. SaaS companies who need to prioritize renewals based on real risk signals rather than gut feeling. Product-led organizations that want to combine usage data + CRM + support into one automated process. Tutorial video Watch the Youtube Tutorial video About me : I’m Yassin a Project & Product Manager Scaling tech products with data-driven project management. 📬 Feel free to connect with me on Linkedin

How It Works The system collects real-time wearable health data, normalizes it, and uses AI to analyze trends and risk scores. It detects anomalies by comparing with historical patterns and automatically triggers alerts and follow-up actions when thresholds are exceeded. Setup Steps Configure Webhook Endpoint - Set up webhook to receive data from wearable devices Connect Database - Initialize storage for health metrics and historical data Set Normalization Rules - Define data standardization parameters for different devices Configure AI Model - Set up health score calculation and risk prediction algorithms Define Thresholds - Establish alert triggers for critical health metrics Connect Notification Channels - Configure email and Slack integrations Set Up Reporting - Create automated report templates and schedules Test Workflow - Run end-to-end tests with sample health data Workflow Template Webhook → Store Database → Normalize Data → Calculate Health Score → Analyze Metrics → Compare Previous → Check Threshold → Generate Reports/Alerts → Email/Slack → Schedule Follow-up Workflow Steps Ingest real-time wearable data via webhook, store and standardize it, and use GPT-4 for trend analysis and risk scoring. Monitor metrics against thresholds, trigger SMS, email, or Slack alerts, generate reports, and schedule follow-ups. Setup Instructions Configure webhook, database, GPT-4 API, notifications, calendar integration, and customize alert thresholds. Prerequisites Wearable API, patient database, GPT-4 key, email SMTP, optional Slack/Twilio, calendar integration. Use Cases Monitor glucose for diabetics, track elderly vitals/fall risk, assess corporate wellness, and post-surgery recovery alerts. Customization Adjust risk algorithms, add metrics, integrate telemedicine. Benefits Early intervention reduces readmissions and automates 80% of monitoring tasks.

Introduction Automate peer review assignment and grading with AI-powered evaluation. Designed for educators managing collaborative assessments efficiently. How It Works Webhook receives assignments, distributes them, AI generates review rubrics, emails reviewers, collects responses, calculates scores, stores results, emails reports, updates dashboards, and posts analytics to Slack. Workflow Template Webhook → Store Assignment → Distribute → Generate Review Rubric → Notify Slack → Email Reviewers → Prepare Response → Calculate Score → Store Results → Check Status → Generate Report → Email Report → Update Dashboard → Analytics → Post to Slack → Respond to Webhook Workflow Steps Receive & Store: Webhook captures assignments, stores data. Distribute & Generate: Assigns peer reviewers, AI creates rubrics. Notify & Email: Alerts via Slack, sends review requests. Collect & Score: Gathers responses, calculates peer scores. Report & Update: Generates reports, emails results, updates dashboard. Analyze & Alert: Posts analytics to Slack, confirms completion. Setup Instructions Webhook & Storage: Configure endpoint, set up database. AI Configuration: Add OpenAI key, customize rubric prompts. Communication: Connect Gmail, Slack credentials. Dashboard: Link analytics platform, configure metrics. Prerequisites OpenAI API key Gmail account Slack workspace Database or storage system Dashboard tool Use Cases University peer review assignments Corporate training evaluations Research paper assessments Customization Multi-round review cycles Custom scoring algorithms Benefits Eliminates manual distribution Ensures consistent evaluation

Turn your blog into a set-and-forget content engine: every new article is instantly repurposed into channel-specific social posts with visuals, keeping your brand visible on LinkedIn, X, and Reddit without extra copywriting time. Perfect for lean marketing teams who want consistent, always-on distribution from a single source of content. How it works • Watches your blog RSS feed (or receives a single URL) and detects new articles. • Saves each post in Postgres so every article is only processed once. • Fetches the article HTML, extracts the main body content and sends it to OpenAI (GPT-4.1). • OpenAI creates platform-optimized copy: 1 LinkedIn post, 1 X/Twitter post, 1 Reddit post + image prompts. • Generates on-brand images with OpenAI and publishes everything automatically to LinkedIn, X, and Reddit. • You can also trigger it manually or via webhook whenever you want to push a specific campaign. Setup Steps • Time: around 20–40 minutes for someone familiar with n8n and the platforms. • Create a Postgres table “rss_items” with fields: guid (PRIMARY KEY), title, link, published_at. • Add credentials in n8n for: – Postgres – OpenAI – LinkedIn OAuth2 – X/Twitter OAuth2 + OAuth1 (for media upload) – Reddit OAuth2 • In the RSS node, set your blog feed URL (for example: https://yourblog.com/feed). • In the webhook node, confirm the URL/path you want external tools or other workflows to call with a “link” field. • Run the manual trigger with one test blog URL to verify: – Article content is extracted correctly. – AI returns LinkedIn/X/Reddit posts and image prompts. – Posts and images appear correctly on all social accounts. • Once tests look good, enable the Schedule Trigger so Blog2Social AI runs automatically at your chosen interval.

Template Description This description details the template's purpose, how it works, and its key features. You can copy and use it directly. Overview This is a powerful n8n "meta-workflow" that acts as a Supervisor. Through a simple Telegram bot, you can dynamically create, manage, and delete countless independent, AI-driven market monitoring agents (Watchdogs). This template is a perfect implementation of the "Workflowception" (workflow managing workflows) concept in n8n, showcasing how to achieve ultimate automation by leveraging the the n8n API. How It Works ? Telegram Bot Interface: Execute all operations by sending commands to your own Telegram Bot: /add SYMBOL INTERVAL PROMPT: Add a new monitoring task. /delete SYMBOL: Delete an existing monitoring task. /list: List all currently running monitoring tasks. /help: Get help information. Use Telegram Bot to control The watchdog workfolw created in the below Dynamic Workflow Management: Upon receiving an /add command, the Supervisor system reads a "Watchdog" template, fills in your provided parameters (like trading pair and time interval), and then automatically creates a brand new, independent workflow via the n8n API and activates it. Persistent Storage: All monitoring tasks are stored in a PostgreSQL database, ensuring your configurations are safe even if n8n restarts. The ID of each newly created workflow is also written back to the database to facilitate future deletion operations. AI-Powered Analysis: Each created "Watchdog" workflow runs on schedule. It fetches the latest candlestick chart by calling a self-hosted tradingview-snapshot service. This service, available at https://github.com/0xcathiefish/tradingview-snapshot, works by simulating a login to your account and then using TradingView's official snapshot feature to generate an unrestricted, high-quality chart image. An example of a generated snapshot can be seen here: https://s3.tradingview.com/snapshots/u/uvxylM1Z.png. To use this, you need to download the Docker image from the packages in the GitHub repository mentioned above, and run it as a container. The n8n workflow then communicates directly with this container via an HTTP API to request and receive the chart snapshot. After obtaining the image, the workflow calls a multimodal AI model (Gemini). It sends both the chart image and your custom text-based conditions (e.g., "breakout above previous high on high volume" or "break below 4-hour MA20") to the AI for analysis, enabling truly intelligent chart interpretation and alert triggering. Key Features Workflowception: A prime example of one workflow using an API to create, activate, and delete other workflows. Full Control via Telegram: Manage your monitoring bots from anywhere, anytime, without needing to log into the n8n interface. AI Visual Analysis: Move beyond simple price alerts. Let an AI "read" the charts for you to enable complex, pattern-based, and indicator-based intelligent alerts. Persistent & Extensible: Built on PostgreSQL for stability and reliability. You can easily add more custom commands.

Automate Microsoft Teams Meeting Analysis with GPT-4.1, Outlook & Mem.ai Watch the YouTube video to get started Follow along with the blog post Template Overview This advanced n8n template automates Microsoft Teams meeting analysis, knowledge base creation, and email drafting directly from meeting recordings and transcripts. It provides end-to-end automation for the following use cases: Meeting Analysis Connects to Microsoft Graph to retrieve meeting recordings, chat messages, and transcripts. Analyses meeting content using AI models. Extracts key points, action items, questions, and themes from meetings automatically. AI-Powered Web App Automatically creates a detailed report from past meetings. Stores meeting summaries, metadata, and insights into an easy-to-browse frontend. New meetings are added dynamically without manual work. ** Knowledge Base Indexing (via Mem.ai)** Uploads extracted meeting data into a structured knowledge base. Supports categorisation, search and chat functionality across meetings. Draft Follow-Up Emails** Draft personalised follow-up emails for meeting participants. Email drafts include: Meeting summary Key decisions Action items Emails can be sent manually with a human in the loop context via Microsoft Outlook integration. Core Components Microsoft Graph API for accessing meetings, chats, files, and user profiles. SharePoint API for file storage and search. n8n Webhooks to trigger processes dynamically. Generic OAuth2 authentication for seamless Microsoft access. JavaScript Code Nodes for flexible, intelligent parsing and structuring of meeting data. AI/LLM nodes for summarisation and content creation. Designed to be scalable, modular, and easily customisable for different organisation sizes and industries. 🛡️ Note Failure to correctly configure Azure permissions will prevent the template from functioning. Ensure admin approval is fully completed during setup. Important Prerequisites ⚠️ Administrator consent is required This template requires a Microsoft 365 Global Administrator or Application Administrator to grant admin consent to a set of Microsoft Graph and SharePoint API scopes. Basic Azure App Registration knowledge is required: You need to set up an Azure App Registration manually, configure OAuth2 authentication, and assign specific API permissions. A setup guide is included, but familiarity with: App registrations API permissions Client secrets OAuth2 flows is highly recommended. Knowledge of Postgres is required The template includes a SQL script to create the required Postgres table (see blog post). You are responsible for hosting your own database (You can use Supabase with the Postgres connection string).

Automatically generates engaging marketing posts using OpenAI and publishes them across LinkedIn, Twitter (X), and Facebook. Creates platform-optimized content with hashtags, emojis, and proper formatting. How it works Trigger — Runs daily at 10 AM or manual trigger for on-demand content Generate — Creates tailored marketing content using OpenAI GPT-4 based on topic/theme Optimize — Customizes content for each platform (character limits, hashtags, tone) Review — Optional human approval gate before publishing Publish — Auto-posts to LinkedIn, Twitter, and Facebook simultaneously Track — Logs all posts to database for analytics and content history Notify — Sends confirmation to Slack with links to published posts Setup steps OpenAI API — Add your OpenAI API key in credentials Social Media APIs — Configure LinkedIn, Twitter (X), and Facebook credentials PostgreSQL — Create social_posts table to store post history Slack — Add webhook URL for notifications Content Topics — Customize the topic list in the initial node Approval (Optional) — Enable/disable manual review gate Test — Run manually first, then activate for daily automation What It Does: Randomly selects content topics and types for variety Generates engaging posts using OpenAI Optimizes content for each platform (character limits, hashtags, tone) Publishes simultaneously to all three platforms Stores complete records in database Sends confirmation notifications to Slack

Coupon Bot Dashboard & WhatsApp Management System A complete bilingual admin dashboard and WhatsApp bot solution for managing discount coupons, partner companies, and customer conversations through an intuitive web interface and automated chatbot. What does this workflow do? This workflow provides a comprehensive coupon management system with dual interfaces: a modern Vue.js admin dashboard for managers and an interactive WhatsApp bot for customers. It handles everything from company onboarding and coupon issuance to real-time customer support and conversation tracking. Key features: 🎛️ Admin Dashboard - Full-featured Vue.js 3 interface with Tailwind CSS for managing companies, coupons, and viewing analytics 🤖 WhatsApp Bot - Automated customer service bot with session-based state management 🏢 Company Management - CRUD operations for partner companies and their coupon catalogs 🎫 Advanced Coupon System - Support for percentage/fixed discounts, expiry dates, minimum purchase requirements, and maximum discount caps 💬 Real-time Inbox - Live chat interface for viewing customer conversation history 🌐 Bilingual Support - Full Arabic (RTL) and English interface support 📊 Analytics Dashboard - Track customers, messages, coupons issued, and partner companies 🔧 Database Tools - Built-in schema initialization and migration capabilities 👤 Role-Based Access - Separate admin and customer flows with phone number authentication Setup Requirements Integrations Needed: PostgreSQL - Primary database for all system data WhatsApp Business API - For customer bot interactions via Facebook Graph API n8n - Workflow automation platform (self-hosted or cloud) Credentials Required: PostgreSQL database credentials (host, port, database, user, password) WhatsApp Business API Bearer Token (Facebook Graph API v22.0) Phone Number ID from WhatsApp Business account How to Use Initial Setup: Import the workflow into your n8n instance Configure PostgreSQL credentials - Connect to your database (named "discounts DB" in the workflow) Configure WhatsApp credentials - Add your Facebook Graph API Bearer Token Initialize the database - Send POST request to /webhook/coupon-bot/execute-init to create all tables Set admin phone - Access dashboard at /webhook/coupon-bot/dashboard, go to Settings, and set your admin phone number Configure WhatsApp webhook - Point your WhatsApp Business webhook to /webhook/whatsapp Dashboard Access: URL**: /webhook/coupon-bot/dashboard Features**: Statistics, Company Management, Coupon Management, Inbox, System Settings Admin WhatsApp Commands: Once your phone is set as admin, send any message to the bot to access: Add/Edit/Delete Companies Add/Edit/Delete Coupons Edit Welcome/End Messages Browse as regular customer Workflow Structure Dashboard Webhook (/coupon-bot/dashboard) Serves the complete Vue.js 3 admin interface with: Responsive RTL layout for Arabic Mobile-optimized sidebar navigation Real-time statistics cards Company and coupon management forms Interactive inbox with chat history System settings and database maintenance tools API Endpoints (/coupon-bot/api/*) RESTful API routes for dashboard operations: POST /stats - System analytics (customers, messages, records, companies) POST /companies - CRUD operations for partner companies POST /coupons - CRUD operations with advanced fields (percentage, expiry, limits) POST /inbox - Retrieve unique customer conversations POST /history - Fetch complete chat history for a customer POST /settings - Manage admin phone and message templates POST /customers - Customer records retrieval POST /records - Coupon redemption tracking Database Management (/coupon-bot/execute-init, /coupon-bot/migrate) Full Initialization** - Creates all tables: customers, companies, coupons, records, messages, settings, sessions Schema Migration** - Non-destructive updates to add missing columns and constraints Repair Tools** - Fixes corrupted data and ensures schema consistency WhatsApp Bot Handler (/webhook/whatsapp) Processes incoming WhatsApp messages with: Authentication** - Detects admin vs. regular customers by phone number Session Management** - PostgreSQL-based state machine for multi-step conversations Interactive Messages** - List menus for company/coupon selection Message Logging** - All incoming/outgoing messages stored for inbox feature Customer Flow (Regular Users) Receive welcome message from settings Browse list of partner companies Select company to view available coupons Choose coupon to receive details Get end message with coupon code and terms Admin Flow (Authenticated Users) Access main management menu Manage companies (add, edit, delete) Manage coupons (add with advanced options, edit, delete) Customize welcome and end messages Test customer experience Database Schema customers customer_id (SERIAL PRIMARY KEY) name (VARCHAR 255) phone (VARCHAR 50, UNIQUE) selected_sites (TEXT) created_at (TIMESTAMP) updated_at (TIMESTAMP) companies company_id (SERIAL PRIMARY KEY) name (VARCHAR 255, NOT NULL) info (TEXT) coupons coupon_id (SERIAL PRIMARY KEY) company_id (INT, FOREIGN KEY) coupon_text (TEXT, NOT NULL) -- The actual coupon code coupon_value (NUMERIC 10,2) is_percentage (BOOLEAN DEFAULT FALSE) has_max (BOOLEAN DEFAULT FALSE) max_value (NUMERIC 10,2) is_max_percentage (BOOLEAN DEFAULT FALSE) has_min_purchase (BOOLEAN DEFAULT FALSE) min_purchase_value (NUMERIC 10,2) is_on_items_quantity (BOOLEAN DEFAULT FALSE) registration_date (TIMESTAMP) has_expiry (BOOLEAN DEFAULT FALSE) expiry_date (TIMESTAMP) other_info (TEXT) records record_id (SERIAL PRIMARY KEY) customer_id (INT, FOREIGN KEY) company_id (INT, FOREIGN KEY) coupon_id (INT, FOREIGN KEY) created_at (TIMESTAMP) messages message_id (SERIAL PRIMARY KEY) customer_id (INT, FOREIGN KEY, nullable) sender_phone (VARCHAR 50) sender_name (VARCHAR 255) external_message_id (VARCHAR 255) message_text (TEXT, NOT NULL) message_type (VARCHAR 50 DEFAULT 'text') direction (VARCHAR 20 DEFAULT 'INCOMING') is_from_customer (BOOLEAN DEFAULT TRUE) created_at (TIMESTAMP) settings key (VARCHAR 50 PRIMARY KEY) value (TEXT) -- Keys: admin_phone, welcome_message, end_message sessions phone (VARCHAR 50 PRIMARY KEY) state (VARCHAR 50, NOT NULL) data (JSONB DEFAULT '{}') last_updated (TIMESTAMP) Session States (State Machine) The bot uses PostgreSQL sessions for conversation persistence: IDLE - Default state, waiting for input WAITING_COMPANY_NAME - Admin adding new company WAITING_EDIT_COMPANY_SELECT - Admin selecting company to edit WAITING_EDIT_COMPANY_NAME - Admin entering new company name WAITING_DELETE_COMPANY_SELECT - Admin selecting company to delete WAITING_ADD_COUPON_COMPANY - Admin selecting company for new coupon WAITING_ADD_COUPON_TEXT - Admin entering coupon code WAITING_ADD_COUPON_VALUE - Admin entering discount value WAITING_EDIT_COUPON_SELECT - Admin selecting coupon to edit WAITING_EDIT_COUPON_TEXT - Admin entering new coupon code WAITING_DELETE_COUPON_SELECT - Admin selecting coupon to delete EDIT_WELCOME - Admin updating welcome message EDIT_END - Admin updating end message Message Templates Default Welcome Message (Customizable): Default End Message (Customizable): Customization Tips Add more languages**: Extend the dashboard and bot to support additional languages beyond Arabic/English Coupon restrictions**: Use the advanced coupon fields to set minimum purchase amounts, maximum discount caps, and expiry dates Analytics enhancement**: Add more statistics nodes to track coupon usage by company or time period Telegram integration**: Duplicate the WhatsApp webhook nodes and modify for Telegram Bot API Email notifications**: Add SMTP nodes to send coupon details via email Multi-admin support**: Modify the settings schema to support multiple admin phone numbers Coupon categories**: Add a categories table and filter coupons by category in the bot Use Cases Marketing agencies managing discount campaigns for multiple clients E-commerce platforms offering partner store coupons Loyalty programs with tiered discount systems Event-based promotional campaigns with expiry dates Multi-vendor marketplaces with individual seller coupons Customer retention programs with personalized offers Technical Notes Frontend**: Vue.js 3 (Composition API) + Tailwind CSS + Font Awesome icons Backend**: n8n workflow automation with PostgreSQL WhatsApp API**: Facebook Graph API v22.0 with interactive list messages Security**: Phone number-based admin authentication, SQL injection protection via parameterized queries Performance**: Database indexing on phone numbers and foreign keys, session cleanup recommended Mobile**: Fully responsive dashboard with mobile-optimized WhatsApp interactions Tags: #n8n #whatsapp #coupons #dashboard #vuejs #postgresql #automation #customer-service #bilingual

SharePoint → Supabase → Google Drive Sync Workflow Overview This workflow is a multi-system document synchronization pipeline built in n8n, designed to automatically sync and back up files between Microsoft SharePoint, Supabase/Postgres, and Google Drive. It runs on a scheduled trigger, compares SharePoint file metadata against your Supabase table, downloads new or updated files, uploads them to Google Drive, and marks records as completed — keeping your databases and storage systems perfectly in sync. Workflow Structure Data Source:** SharePoint REST API for recursive folder and file discovery. Processing Layer:** n8n logic for filtering, comparison, and metadata normalization. Destination Systems:** Supabase/Postgres for metadata, Google Drive for file backup. SharePoint Sync Flow (Frontend Flow) Trigger:** Schedule Trigger Runs at fixed intervals (customizable) to start synchronization. Fetch Files:** Microsoft SharePoint HTTP Request Recursively retrieves folders and files using SharePoint’s REST API: /GetFolderByServerRelativeUrl(...)?$expand=Files,Folders,Folders/Files,Folders/Folders/Folders/Files Filter Files:** filter files A Code node that flattens nested folders and filters unwanted file types: Excludes system or temporary files (~$) Excludes extensions: .db, .msg, .xlsx, .xlsm, .pptx Normalize Metadata:** normalize last modified date Ensures consistent Last_modified_date format for accurate comparison. Fetch Existing Records:** Supabase (Get) Retrieves current entries from n8n_metadata to compare against SharePoint files. Compare Datasets:** Compare Datasets Detects new or modified files based on UniqueId, Last_modified_date, and Exists. Routes only changed entries forward for processing. File Processing Engine (Backend Flow) Loop:** Loop Over Items2 Iterates through each new or updated file detected. Build Metadata:** get metadata and Set metadata Constructs final metadata fields: file_id, file_title, file_url, file_type, foldername, last_modified_date Generates fileUrl using UniqueId and ServerRelativeUrl if missing. Upsert Metadata:** Insert Document Metadata Inserts or updates file records in Supabase/Postgres (n8n_metadata table). Operation: upsert with id as the primary matching key. Download File:** Microsoft SharePoint HTTP Request1 Fetches the binary file directly from SharePoint using its ServerRelativeUrl. Rename File:** rename files Renames each downloaded binary file to its original file_title before upload. Upload File:** Upload file Uploads the renamed file to Google Drive (My Drive → root folder). Mark Complete:** Postgres Updates the Supabase/Postgres record setting Loading Done = true. Optional Cleanup:** Supabase1 Deletes obsolete or invalid metadata entries when required. Integrations Used | Service | Purpose | Credential | |----------|----------|-------------| | Microsoft SharePoint | File retrieval and download | microsoftSharePointOAuth2Api | | Supabase / Postgres | Metadata storage and synchronization | Supabase account 6 ayan | | Google Drive | File backup and redundancy | Google Drive account 6 rn dbt | | n8n Core | Flow control, dataset comparison, batch looping | Native | System Prompt Summary > “You are a SharePoint document synchronization workflow. Fetch all files, compare them to database entries, and only process new or modified files. Download files, rename correctly, upload to Google Drive, and mark as completed in Supabase.” Workflow rule summary: > “Maintain data integrity, prevent duplicates, handle retries gracefully, and continue on errors. Skip excluded file types and ensure reliable backups between all connected systems.” Key Features Scheduled automatic sync across SharePoint, Supabase, and Google Drive Intelligent comparison to detect only new or modified files Idempotent upsert for consistent metadata updates Configurable file exclusion filters Safe rename + upload pipeline for clean backups Error-tolerant and fully automated operation Summary > A reliable, SharePoint-to-Google Drive synchronization workflow built with n8n, integrating Supabase/Postgres for metadata management. It automates file fetching, filtering, downloading, uploading, and marking as completed — ensuring your data stays mirrored across platforms. Perfect for enterprises managing document automation, backup systems, or cross-cloud data synchronization. Need Help or More Workflows? Want to customize this workflow for your organization? Our team at Digital Biz Tech can extend it for enterprise-scale document automation, RAGs and social media automation. We can help you set it up for free — from connecting credentials to deploying it live. Contact: [email protected] Website: https://www.digitalbiz.tech LinkedIn: https://www.linkedin.com/company/digital-biz-tech/ You can also DM us on LinkedIn for any help.

🚀 What this flow does • 🔎 Selects the least-used WordPress category (tracked in PostgreSQL) • 🤖 Uses GPT (4-mini or better) to generate a fully formatted SEO article with headings, TOC, lists, CTA, and Yoast blocks • 🖼️ Creates a placeholder cover image and uploads it to WordPress Media • 📬 Publishes the final post via /wp-json/wp/v2/posts with correct category + featured image • 🧠 Logs the used category for future rotation (zero duplicates!) ⚙️ Setup in 3 mins 🏷️ Add your WordPress domain with a simple Set node:     domain=https://yourdomain.com 🔐 Create these 3 credentials in n8n:     YOUR_WORDPRESS_CREDENTIAL — for /media, /posts     YOUR_POSTGRES_CREDENTIAL — for category tracking     YOUR_OPENAI_CREDENTIAL — GPT-4-mini or better 🧱 Run the SQL from docs to create the used_categories table ✅ Manually test first 3–5 nodes to check WP auth, OpenAI response, and DB connection 🕒 Then just schedule it and let the bot write for you. 🎯 Why it's awesome This is your personal AI content writer + publisher — perfect for: • 📰 SEO content farms • 📈 Affiliate blogs • 🧰 Micro niche sites • 🤫 PBNs with rotation-safe automation No more manual uploads, broken categories, or GPT spam. Every post is structured, beautiful, and intelligently categorized.

💅 AI Agents Generate Content & Automate Posting for Beauty Salon Social Media 📲 Who Is This For? This workflow is for beauty salons who want consistent, high‑quality social media content without writing every post manually. It also suits agencies and automation builders who manage multiple beauty brands and want a reusable, AI‑driven posting system they can adapt per client. What Problem Is This Workflow Solving? Many beauty businesses struggle to post regularly because research, copywriting, and design all take time and marketing skills. This workflow automates research, writing, image creation, and posting, so your channels stay active and relevant while you focus on clients and services. What This Workflow Does Generates short, engaging posts tailored to a beauty‑salon audience (hair, nails, skincare, make‑up, self‑care) using an AI agent. Uses Tavily Internet Search to pull up‑to‑date information and trends based on a reference link or topic. Turns each post into a detailed, photorealistic image prompt and creates a matching visual with an AI image model (for example, gpt‑image‑1 or other connected providers). Automatically sends the final text and image to Telegram, and can be extended to other social platforms from the Split Out node. How It Works Trigger the workflow Scheduled automatic generation:** Run the parent workflow on a schedule (for example, once per day at 9 AM) to publish new content regularly. Google Sheets trigger:** Generate content when a new row with a reference link or topic is added to your sheet. Use it when you manage ideas or briefs in Google Sheets and want the workflow to react as soon as a new idea appears. RSS Feed trigger:** Start the workflow when new items appear in a selected RSS feed. Ideal for turning fresh blog posts, news, or industry updates into social media content or automated summaries. Meta (Facebook/Instagram) webhook:** Use the Meta Reference trigger to fire the workflow on incoming webhooks from Meta (for example, new comments, messages, or events). Helpful when you want to auto‑respond, log activity, or generate follow‑up content from Meta activity. Airtable trigger:** Start the workflow when records in a selected Airtable base/table change (for example, a new idea, brief, or status update), so your posts react instantly to updates in your Airtable content board. Postgres trigger:** Fire the workflow when new rows are inserted or existing rows are updated in a connected PostgreSQL table, letting you drive content generation from events in your app database or Supabase‑style back end. Manual start:* Hit Execute workflow* whenever you want to spin up a batch of posts on demand, test new prompt settings, or debug the flow step by step. Research and generate copy The GENERATE TEXT agent calls Tavily to gather fresh information on the topic. It writes a post under 1024 characters with a hook, practical tips, relevant hashtags, and a closing line with your salon address and contact. Create the visual The GENERATE PROMPT agent converts the post into a single, clear description of the scene (client, service, salon interior, lighting, mood) with a strict “no text on image” rule. An image model such as gpt‑image‑1 or one of the HTTP image APIs renders a matching beauty visual. Distribute the content The Split Out node fans out the result so Telegram receives a photo post with the generated caption. Additional social or content nodes (for example Facebook, LinkedIn, X, template tools) can be wired after this step for multi‑channel posting. How to Customize This Workflow to Your Needs Brand voice** Edit the system message in the GENERATE TEXT node to adjust tone (luxury, friendly, clinical, playful), language, services, and city. Update the final address and phone line to match your salon details. Topics and triggers** Point the Google Sheets Trigger to your own document ID, sheet, and columns for ideas, links, or campaign themes. Use the Schedule Trigger for fully automatic posting or rely on the Manual Trigger for controlled, batch generation sessions. Models and providers** Swap GPT‑5 llm and the default image model for alternatives such as Mistral, Gemini, Anthropic, DeepSeek, or custom HTTP image APIs by enabling the corresponding nodes and adding credentials. Channels and outputs** Connect or remove social nodes after Split Out depending on which platforms you actively use. Add extra processing steps (for example resizing images or adding UTM parameters) before each channel if needed. Visual style** Tweak the GENERATE PROMPT instructions to control composition (close‑up vs. full‑body), color palette, lighting, and overall salon aesthetic, while keeping the constraint of no text or logos in the image.

Video Guide I prepared a detailed guide explaining how to build an AI-powered meeting assistant that provides real-time transcription and insights during virtual meetings. Youtube Link Who is this for? This workflow is ideal for business professionals, project managers, and team leaders who require effective transcription of meetings for improved documentation and note-taking. It's particularly beneficial for those who conduct frequent virtual meetings across various platforms like Zoom and Google Meet. What problem does this workflow solve? Transcribing meetings manually can be tedious and prone to error. This workflow automates the transcription process in real-time, ensuring that key discussions and decisions are accurately captured and easily accessible for later review, thus enhancing productivity and clarity in communications. What this workflow does The workflow employs an AI-powered assistant to join virtual meetings and capture discussions through real-time transcription. Key functionalities include: Automatic joining of meetings on platforms like Zoom, Google Meet, and others with the ability to provide real-time transcription. Integration with transcription APIs (e.g., AssemblyAI) to deliver seamless and accurate capture of dialogue. Structuring and storing transcriptions efficiently in a database for easy retrieval and analysis. Real-Time Transcription: The assistant captures audio during meetings and transcribes it in real-time, allowing participants to focus on discussions. Keyword Recognition: Key phrases can trigger specific actions, such as noting important points or making prompts to the assistant. Structured Data Management: The assistant maintains a database of transcriptions linked to meeting details for organized storage and quick access later. Setup Preparation Create Recall.ai API key Setup Supabase account and table create table public.data ( id uuid not null default gen_random_uuid (), date_created timestamp with time zone not null default (now() at time zone 'utc'::text), input jsonb null, output jsonb null, constraint data_pkey primary key (id), ) tablespace pg_default; Create OpenAI API key Development Bot Creation: Use a node to create the bot that will join meetings. Provide the meeting URL and set transcription options within the API request. Authentication: Configure authentication settings via a Bearer token for interacting with your transcription service. Webhook Setup: Create a webhook to receive real-time transcription updates, ensuring timely data capture during meetings. Join Meeting: Set the bot to join the specified meeting and actively listen to capture conversations. Transcription Handling: Combine transcription fragments into cohesive sentences and manage dialog arrays for coherence. Trigger Actions on Keywords: Set up keyword recognition that can initiate requests to the OpenAI API for additional interactions based on captured dialogue. Output and Summary Generation: Produce insights and summary notes from the transcriptions that can be stored back into the database for future reference.

Video explanation This n8n workflow helps you identify trending videos within your niche by detecting outlier videos that significantly outperform a channel's average views. It automates the process of monitoring competitor channels, saving time and streamlining content research. Included in the Workflow Automated Competitor Video Tracking Monitors videos from specified competitor channels, fetching data directly from the YouTube API. Outlier Detection Based on Channel Averages Compares each video’s performance against the channel’s historical average to identify significant spikes in viewership. Historical Video Data Management Stores video statistics in a PostgreSQL database, allowing the workflow to only fetch new videos and optimize API usage. Short Video Filtering Automatically removes short videos based on duration thresholds. Flexible Video Retrieval Fetches up to 3 months of historical data on the first run and only new videos on subsequent runs. PostgreSQL Database Integration Includes SQL queries for database setup, video insertion, and performance analysis. Configurable Outlier Threshold Focuses on videos published within the last two weeks with view counts at least twice the channel's average. Data Output for Analysis Outputs best-performing videos along with their engagement metrics, making it easier to identify trending topics. Requirements n8n installed on your machine or server A valid YouTube Data API key Access to a PostgreSQL database This workflow is intended for educational and research purposes, helping content creators gain insights into what topics resonate with audiences without manual daily monitoring.

How it works You provide a list of prompts and a system instruction, the workflow batches them into a single OpenAI Batch API request. The batch job is tracked in a Supabase openai_batches table. A cron job polls OpenAI every 5 minutes, and once the batch completes, the results are decoded and stored back in Supabase. Set up steps Create the openai_batches table in Supabase. Schema is in the yellow sticky note. Add your OpenAI and Supabase/Postgres credentials to the workflow. Replace the mock data with your actual prompts and you're ready to go!

Who Is This For? This workflow is designed for marketers, content creators, agencies, and solo founders who want to publish long‑form posts with visuals on autopilot using n8n and AI agents. ​ Whether you run a blog, SaaS, personal brand, newsletter, or client accounts, this tool helps you keep a consistent content pipeline without manually writing every article, creating images, and posting to each platform one by one. ​ ​ 💪🏼 While the template is wired around classic blog + social media distribution, the underlying logic is universal. You can easily adapt it to any niche by editing prompts, swapping models, and re‑wiring nodes. You can plug in any LLM you like, from ChatGPT to Claude, Gemini, Mistral, DeepSeek, OpenRouter, or even local models through Ollama. ​ What Problem Is This Workflow Solving? 🤯 Most teams waste hours on the same repetitive loop: research a topic, gather links, write a blog post, craft social captions, generate visuals, upload everything to multiple platforms, and archive assets. ​ ​ 💎 This workflow solves that by automating the full content chain—from research and blog‑post generation to image creation, publishing across channels, and logging everything in your content database—so your feeds stay active while you focus on strategy, not busywork. ​ What This Workflow Does ✨ Generates in‑depth blog posts tailored to your topic and target audience, enriched with fresh references from the web via Tavily/SerpAPI search tools. ​ ✨ Creates an image prompt and title from the article, generates the visual with OpenAI Images (gpt-image-1), and converts it into a ready‑to‑use image file. ​ ✨ Automatically publishes content to your connected platforms (WordPress for blog posts, Telegram, X/Twitter, Facebook, LinkedIn) while saving images to Google Drive and logging each publication in Google Sheets for tracking. ​ How It Works? Surprisingly simple ☺️ The workflow is triggered by another n8n workflow or by one of several triggers (Facebook, RSS, Google Sheets, Airtable, Postgres) that pass in the blogTopic, targetAudience, and Telegram chatID. ​ ​ The Blog Post Agent (LLM with access to Tavily/SerpAPI) researches the topic, writes a structured article for the specified audience, and sends its output to the Image Prompt Agent, which turns the content into a visual prompt and title. ​ 🎯 The end result: you provide a topic, run the workflow, and receive a complete blog post, matching image, and ready‑made social posts shipped directly to your channels and archives—no manual copy‑paste. ​ How to Customize This Workflow to Your Needs 🎨 Switch AI models and fine‑tune prompts so the agent can handle your exact formats: tutorials, case studies, listicles, product updates, thought‑leadership pieces, or campaign landing posts. 🔍 Refine research sources inside Tavily/SerpAPI to prioritize the domains, blogs, and docs your audience trusts, keeping posts accurate and up to date. ⏰ Adjust posting cadence and schedules to align with peak engagement for your audience, mixing automated slots with manual “launch” runs for special announcements. 📱 Expand or trim channels as needed: keep just WordPress + LinkedIn, add Telegram as a content feed, or plug the workflow into additional automations like email campaigns or RSS feeds. 📊 Use Google Sheets as your content hub to store ideas, angles, CTAs, references, and performance notes so you can double‑down on topics and formats that perform best. 🎬 Swap images for video by replacing the image generation node with video tools (for example, Runway‑style APIs) if your strategy is video‑first while keeping the same prompt pipeline. 💾 Build a reusable prompt library in Sheets, Notion, or Airtable so you can rotate proven prompt patterns each month and keep quality high without reinventing the wheel. 🤖 The system will continuously generate blog posts, visuals, and social updates and publish them across your selected platforms while archiving everything in Drive and Sheets—keeping your brand visible, consistent, and professional with minimal ongoing effort.

Overview This n8n workflow retrieves AI agent chat memory logs stored in Postgres and pushes them to Google Sheets, creating one sheet per session. It’s useful for teams building chat-based products or agents and needing to review or analyze session logs in a collaborative format. Who is it for Anyone with an AI Agent in Production storing the conversation logs in Postgres (or Supabase) who wants to see transcript and have control Product teams building AI agents or assistants. Teams that want to centralize conversation history for analysis or support. Anyone managing AI chat memory and needing to explore it in a spreadsheet. Prerequisites A Postgres database with a n8n_chat_histories table with an AI Agent connected to it. If you need an example, you can follow this tutorial Once done, you need to run the Postgresql query to add the created_at column (see Setup > Add a datetime column) Google Sheets access and OAuth credentials connected to n8n. A Google Sheets document set up as a template (see below). Google Sheets Template This workflow expects a Google Sheets file where each session will be stored in its own tab. A basic tab layout is duplicated and renamed with the session ID. 👉 Use this template as a starting point Note: You can hide the template after the first tabs have been created How it works Trigger The workflow can be launched manually or on a schedule (e.g. daily at noon). Retrieve sessions Runs a SQL query to get distinct session_id values from the n8n_chat_histories table. Loop over sessions For each session: Clears the corresponding sheet (if it exists). Duplicates the template tab. Renames it with the current session_id. Fetch messages Selects all messages linked to the session from Postgres. Append to sheet Adds each message to the Google Sheet with columns: Who: speaker role (user, assistant, etc.) Message: text content Date: timestamp from created_at, formatted yyyy-MM-dd hh:mm:ss Notes The sheet is cleared and rebuilt each run to ensure logs are up-to-date. If a sheet for a session doesn’t exist, it will be created by duplicating the first tab (template) You can group sessions under a persistent ID (like user_id) by overriding session_id in your memory config. Works perfectly with Supabase by using PG credentials from the connection pooler. 👉 If you're looking for a solution to better visualize and analyse conversations, reach out to us!

AI-Powered WhatsApp Assistant for Restaurant & Delivery – Automate Orders, Calculate Delivery Fees & Enhance Customer Service with n8n 📌 Optimize your restaurant's delivery process with AI-powered automation! This n8n workflow enables an intelligent WhatsApp assistant for restaurants, burger joints, and delivery businesses. The AI chatbot efficiently handles orders, calculates delivery fees based on distance, manages customer interactions, and seamlessly integrates with your CRM and database for streamlined operations. ⚠️ Important Notice: This template is only compatible with self-hosted n8n instances as it uses community nodes. Ensure secure credential management when configuring APIs. 🔹 Key Features ✅ AI-Powered Order Processing – Automatically receive and confirm orders via WhatsApp. ✅ Real-Time Distance Calculation – Determines the delivery distance and calculates the fee dynamically. ✅ Automated Customer Interaction – Engages customers with intelligent conversation and order updates. ✅ WhatsApp Integration – Processes messages, saves customer details, and retrieves past interactions. ✅ Secure Customer Data Storage – Saves order history, customer preferences, and location details in a database. ✅ Seamless CRM & POS System Integration – Sync orders and customer data with your existing platforms. 📌 How It Works 1️⃣ A customer sends a message via WhatsApp to start an order. 2️⃣ The AI assistant guides them through the menu, recommends items, and confirms their choices. 3️⃣ The system retrieves and saves customer details (name, phone number, and address). 4️⃣ The AI calculates the delivery distance and applies the appropriate delivery fee. 5️⃣ The order details are saved and forwarded to the restaurant’s system for preparation. 6️⃣ The assistant keeps the customer updated about the order status. ⚙️ Setup & Customization 🔧 Webhook for WhatsApp – Capture and process customer messages automatically. 🔧 OpenAI-Powered AI Assistant – Configure conversation flows for natural and engaging interactions. 🔧 Delivery Fee Calculation – Set your delivery price per kilometer and adjust base rates. 🔧 Database & CRM Integration – Store customer details, order history, and location data. 🔧 Customizable Order Flow – Adapt the workflow for different restaurant models. 🔧 Secure Credential Management – Store API keys safely to prevent unauthorized access. 💡 Requirements: This template is recommended for users with basic knowledge of n8n. If you need custom development or setup assistance, contact us via WhatsApp: +55 17 99155-7874. 🚀 Automate order processing, reduce manual tasks, and improve customer satisfaction with AI-powered WhatsApp automation! Assistente de WhatsApp com IA para Restaurantes & Delivery – Automatize Pedidos, Calcule Taxas de Entrega e Melhore o Atendimento ao Cliente com n8n 📌 Otimize o processo de entrega do seu restaurante com automação baseada em IA! Este fluxo para n8n permite criar um atendente virtual inteligente no WhatsApp, ideal para hamburguerias, restaurantes e serviços de delivery. O chatbot baseado em IA recebe pedidos, calcula a taxa de entrega com base na distância, interage com os clientes e integra-se ao seu CRM para operações mais eficientes. ⚠️ Aviso Importante: Este template é compatível apenas com instâncias auto-hospedadas do n8n, pois utiliza nós da comunidade. Certifique-se de gerenciar credenciais de forma segura ao configurar APIs. 🔹 Principais Funcionalidades ✅ Processamento Inteligente de Pedidos – Recebe e confirma pedidos automaticamente via WhatsApp. ✅ Cálculo Dinâmico da Taxa de Entrega – Mede a distância e aplica a taxa correta automaticamente. ✅ Atendimento Automatizado ao Cliente – Interage com clientes de forma natural e profissional. ✅ Integração com WhatsApp – Captura mensagens, armazena dados e recupera histórico de pedidos. ✅ Armazenamento Seguro de Dados do Cliente – Salva pedidos, preferências e endereços de entrega. ✅ Sincronização com CRM e Sistema de PDV – Conecta-se ao seu sistema de gestão para um fluxo contínuo. 📌 Como Funciona 1️⃣ O cliente envia uma mensagem via WhatsApp para iniciar um pedido. 2️⃣ O assistente de IA apresenta o menu, sugere itens e confirma a escolha do cliente. 3️⃣ O sistema captura e salva os dados do cliente (nome, telefone e endereço). 4️⃣ A IA calcula a distância de entrega e aplica a taxa de acordo com a localização. 5️⃣ Os detalhes do pedido são registrados e enviados para a cozinha. 6️⃣ O assistente atualiza o cliente sobre o status do pedido. ⚙️ Configuração e Personalização 🔧 Webhook para WhatsApp – Configuração para capturar e processar pedidos automaticamente. 🔧 Assistente de IA com OpenAI – Configuração de fluxos conversacionais naturais e envolventes. 🔧 Cálculo de Taxa de Entrega – Definição de valores por quilômetro e ajustes de tarifas base. 🔧 Banco de Dados & CRM – Armazena dados de clientes, histórico de pedidos e localização. 🔧 Fluxo de Pedidos Personalizável – Adapte para diferentes tipos de restaurantes e serviços de delivery. 🔧 Gerenciamento Seguro de Credenciais – Proteja suas chaves de API contra acessos não autorizados. 💡 Requisitos: Este template é recomendado para usuários que já possuem conhecimentos básicos em n8n. Se precisar de personalização ou suporte para instalação, entre em contato pelo WhatsApp: +55 17 99155-7874. 🚀 Automatize o processamento de pedidos, reduza tarefas manuais e melhore a satisfação dos clientes com um WhatsApp automatizado e inteligente!

🐶🤖 AI Agent for Pet Shops – Automate Customer Service & Bookings! 🐾💡 Transform Your Pet Shop with AI-Powered Automation! 🚀 Enhance customer experience and optimize operations with this n8n AI Agent designed for pet shops. 📲🐾 Automate client interactions, appointment scheduling, and service recommendations—saving time and increasing revenue! 🔹 Key Features: ✅ Instant WhatsApp responses – AI-powered chatbot handles customer inquiries. 💬 ✅ Automated appointment scheduling – Clients can book services hassle-free. 📅✂️ ✅ Personalized reminders – Reduce no-shows with automated notifications. 📢🐾 ✅ Customer data & service history management – Track interactions effortlessly. 📊📁 ✅ Product & service recommendations – Improve sales with smart suggestions. 🎁🐶 📌 How It Works 1️⃣ The workflow captures customer inquiries via WhatsApp. 2️⃣ AI processes requests, provides information, and offers booking options. 3️⃣ Clients can schedule grooming, vet visits, or other services in seconds. 4️⃣ Automated reminders ensure appointments are remembered. 5️⃣ Customer data is stored for better service personalization. ⚙️ Setup & Customization 🔧 Connect your WhatsApp API (evolution) for instant messaging. 🔧 Integrate with Google Calendar for appointment booking. 🔧 Customize reminders, services, and pricing rules to fit your business. 💡 Reduce manual work, improve customer satisfaction, and scale your pet shop with AI automation! 🐶🤖 [PT-BR] Agente de IA para Pet Shops – Atendimento e Agendamentos Automatizados! 🐾💡 Transforme Seu Pet Shop com Automação Inteligente! 🚀 Otimize o atendimento ao cliente e agilize processos com este Agente de IA para n8n. 📲🐾 Automatize interações, agendamentos e recomendações de serviços—economizando tempo e aumentando as vendas! 🔹 Principais Funcionalidades: ✅ Atendimento automático no WhatsApp – IA responde clientes instantaneamente. 💬 ✅ Agendamento de serviços automatizado – Clientes marcam banho, tosa ou consultas facilmente. 📅✂️ ✅ Lembretes personalizados – Reduza faltas com notificações automáticas. 📢🐾 ✅ Gestão de clientes e histórico de serviços – Controle dados de forma eficiente. 📊📁 ✅ Sugestão de produtos e serviços – Venda mais com recomendações inteligentes. 🎁🐶 📌 Como Funciona 1️⃣ O fluxo recebe perguntas dos clientes via WhatsApp. 2️⃣ A IA processa os pedidos e fornece opções de agendamento. 3️⃣ O cliente escolhe o serviço desejado e agenda em segundos. 4️⃣ Lembretes automáticos garantem que os clientes não esqueçam os horários. 5️⃣ O histórico do cliente é salvo para oferecer um atendimento mais personalizado. ⚙️ Configuração e Personalização 🔧 Conecte sua API do WhatsApp (evolution) para interação automática. 🔧 Integre ao Google Calendar para gerenciar agendamentos. 🔧 Personalize valores, serviços e regras de envio de lembretes conforme sua necessidade. 💡 Automatize processos, melhore a experiência do cliente e escale seu pet shop com IA! 🚀

This is the first version of a template for a RAG/GenAI App using WordPress content. As creating, sharing, and improving templates brings me joy 😄, feel free to reach out on LinkedIn if you have any ideas to enhance this template! How It Works This template includes three workflows: Workflow 1**: Generate embeddings for your WordPress posts and pages, then store them in the Supabase vector store. Workflow 2**: Handle upserts for WordPress content when edits are made. Workflow 3**: Enable chat functionality by performing Retrieval-Augmented Generation (RAG) on the embedded documents. Why use this template? This template can be applied to various use cases: Build a GenAI application that requires embedded documents from your website's content. Embed or create a chatbot page on your website to enhance user experience as visitors search for information. Gain insights into the types of questions visitors are asking on your website. Simplify content management by asking the AI for related content ideas or checking if similar content already exists. Useful for internal linking. Prerequisites Access to Supabase for storing embeddings. Basic knowledge of Postgres and pgvector. A WordPress website with content to be embedded. An OpenAI API key Ensure that your n8n workflow, Supabase instance, and WordPress website are set to the same timezone (or use GMT) for consistency. Workflow 1 : Initial Embedding This workflow retrieves your WordPress pages and posts, generates embeddings from the content, and stores them in Supabase using pgvector. Step 0 : Create Supabase tables Nodes : Postgres - Create Documents Table: This table is structured to support OpenAI embedding models with 1536 dimensions Postgres - Create Workflow Execution History Table These two nodes create tables in Supabase: The documents table, which stores embeddings of your website content. The n8n_website_embedding_histories table, which logs workflow executions for efficient management of upserts. This table tracks the workflow execution ID and execution timestamp. Step 1 : Retrieve and Merge WordPress Pages and Posts Nodes : WordPress - Get All Posts WordPress - Get All Pages Merge WordPress Posts and Pages These three nodes retrieve all content and metadata from your posts and pages and merge them. Important: * *Apply filters to avoid generating embeddings for all site content. Step 2 : Set Fields, Apply Filter, and Transform HTML to Markdown Nodes : Set Fields Filter - Only Published & Unprotected Content HTML to Markdown These three nodes prepare the content for embedding by: Setting up the necessary fields for content embeddings and document metadata. Filtering to include only published and unprotected content (protected=false), ensuring private or unpublished content is excluded from your GenAI application. Converting HTML to Markdown, which enhances performance and relevance in Retrieval-Augmented Generation (RAG) by optimizing document embeddings. Step 3: Generate Embeddings, Store Documents in Supabase, and Log Workflow Execution Nodes: Supabase Vector Store Sub-nodes: Embeddings OpenAI Default Data Loader Token Splitter Aggregate Supabase - Store Workflow Execution This step involves generating embeddings for the content and storing it in Supabase, followed by logging the workflow execution details. Generate Embeddings: The Embeddings OpenAI node generates vector embeddings for the content. Load Data: The Default Data Loader prepares the content for embedding storage. The metadata stored includes the content title, publication date, modification date, URL, and ID, which is essential for managing upserts. ⚠️ Important Note : Be cautious not to store any sensitive information in metadata fields, as this information will be accessible to the AI and may appear in user-facing answers. Token Management: The Token Splitter ensures that content is segmented into manageable sizes to comply with token limits. Aggregate: Ensure the last node is run only for 1 item. Store Execution Details: The Supabase - Store Workflow Execution node saves the workflow execution ID and timestamp, enabling tracking of when each content update was processed. This setup ensures that content embeddings are stored in Supabase for use in downstream applications, while workflow execution details are logged for consistency and version tracking. This workflow should be executed only once for the initial embedding. Workflow 2, described below, will handle all future upserts, ensuring that new or updated content is embedded as needed. Workflow 2: Handle document upserts Content on a website follows a lifecycle—it may be updated, new content might be added, or, at times, content may be deleted. In this first version of the template, the upsert workflow manages: Newly added content** Updated content** Step 1: Retrieve WordPress Content with Regular CRON Nodes: CRON - Every 30 Seconds Postgres - Get Last Workflow Execution WordPress - Get Posts Modified After Last Workflow Execution WordPress - Get Pages Modified After Last Workflow Execution Merge Retrieved WordPress Posts and Pages A CRON job (set to run every 30 seconds in this template, but you can adjust it as needed) initiates the workflow. A Postgres SQL query on the n8n_website_embedding_histories table retrieves the timestamp of the latest workflow execution. Next, the HTTP nodes use the WordPress API (update the example URL in the template with your own website’s URL and add your WordPress credentials) to request all posts and pages modified after the last workflow execution date. This process captures both newly added and recently updated content. The retrieved content is then merged for further processing. Step 2 : Set fields, use filter Nodes : Set fields2 Filter - Only published and unprotected content The same that Step 2 in Workflow 1, except that HTML To Makrdown is used in further Step. Step 3: Loop Over Items to Identify and Route Updated vs. Newly Added Content Here, I initially aimed to use 'update documents' instead of the delete + insert approach, but encountered challenges, especially with updating both content and metadata columns together. Any help or suggestions are welcome! :) Nodes: Loop Over Items Postgres - Filter on Existing Documents Switch Route existing_documents (if documents with matching IDs are found in metadata): Supabase - Delete Row if Document Exists: Removes any existing entry for the document, preparing for an update. Aggregate2: Used to aggregate documents on Supabase with ID to ensure that Set Fields3 is executed only once for each WordPress content to avoid duplicate execution. Set Fields3: Sets fields required for embedding updates. Route new_documents (if no matching documents are found with IDs in metadata): Set Fields4: Configures fields for embedding newly added content. In this step, a loop processes each item, directing it based on whether the document already exists. The Aggregate2 node acts as a control to ensure Set Fields3 runs only once per WordPress content, effectively avoiding duplicate execution and optimizing the update process. Step 4 : HTML to Markdown, Supabase Vector Store, Update Workflow Execution Table The HTML to Markdown node mirrors Workflow 1 - Step 2. Refer to that section for a detailed explanation on how HTML content is converted to Markdown for improved embedding performance and relevance. Following this, the content is stored in the Supabase vector store to manage embeddings efficiently. Lastly, the workflow execution table is updated. These nodes mirros the **Workflow 1 - Step 3 nodes. Workflow 3 : An example of GenAI App with Wordpress Content : Chatbot to be embed on your website Step 1: Retrieve Supabase Documents, Aggregate, and Set Fields After a Chat Input Nodes: When Chat Message Received Supabase - Retrieve Documents from Chat Input Embeddings OpenAI1 Aggregate Documents Set Fields When a user sends a message to the chat, the prompt (user question) is sent to the Supabase vector store retriever. The RPC function match_documents (created in Workflow 1 - Step 0) retrieves documents relevant to the user’s question, enabling a more accurate and relevant response. In this step: The Supabase vector store retriever fetches documents that match the user’s question, including metadata. The Aggregate Documents node consolidates the retrieved data. Finally, Set Fields organizes the data to create a more readable input for the AI agent. Directly using the AI agent without these nodes would prevent metadata from being sent to the language model (LLM), but metadata is essential for enhancing the context and accuracy of the AI’s response. By including metadata, the AI’s answers can reference relevant document details, making the interaction more informative. Step 2: Call AI Agent, Respond to User, and Store Chat Conversation History Nodes: AI Agent** Sub-nodes: OpenAI Chat Model Postgres Chat Memories Respond to Webhook** This step involves calling the AI agent to generate an answer, responding to the user, and storing the conversation history. The model used is gpt4-o-mini, chosen for its cost-efficiency.

How can you find your target market if you don't know what your product is. This simple philosophy changes the way we think about automated sales agents. Context changes everything. In this 4-part workflow, we start by creating a knowledge base that will act as context across the workflow. This context will guide and provide our AI Agents across the workflow to locate better leads and perform market research based on what the product actually offers. Use Case: Lead generation for Product-based Sales Tech Required Neon DB**: For storing Research and Lead Data. You can use Google sheets but it has a rate limiting problem. Google Serper**: As a web search tool for our AI. Google Drive**: For storing our knowledge base documents. Pinecone**: Vector DB for converting our knowledge base into context for AI. Hunter.io**: For finding emails for outreach. Email Client**: An email client, maybe gmail or anything that can send an email on your behalf. Gemini**: Our trusty AI LLM. Good to know All of the tools that I use in this workflow are either free or have an extremely generous free-tier. How it works We start by converting our knowledge base into context for AI. Take in the documents from Google drive and convert it into embeddings and store them in a vector store like Pinecone. This needs to be only run once, or whenever you have a new document in your knowledge base. Then we pass this context to an AI agent and tell it to generate search queries for locating companies that actually need my services. Then for each company that we've located, we determine the company staff that we need to reach out to for selling our product. This will be done by a combination of Google Serper and Hunter.io Once we have the list of employees and their emails, we start creating personalized emails based on the data we've collected for each of the employee and send them outreach emails.

How It Works This workflow automates hospital emergency department triage by intelligently processing patient intake information through multiple AI-powered assessment stages. Designed for emergency departments, urgent care centers, and hospital admission teams, it solves the critical challenge of rapid, accurate patient prioritization during high-volume periods. The system captures initial patient data through a chat interface, uses specialized AI agents to analyze medical history and current symptoms, validates business rules for priority assignment, performs stability checks, calculates priority scores, and determines required actions. It then routes patients to appropriate care pathways while sending notifications to relevant medical teams and logging all interactions for audit compliance. The workflow leverages OpenAI models and structured JSON parsing to ensure consistent, protocol-driven triage decisions. Setup Steps Configure OpenAI credentials with API key for AI agent access Set up Hospital Triage Agent node with your clinical triage protocols Configure Patient Consent and Structured JSON checkers with validation rules Connect notification endpoints for Execute Appointment and Send Notification nodes Set up audit logging system integration in Log Interactions node Customize business rule validation parameters for your facility's triage categories Prerequisites Active OpenAI API account, hospital system API access for appointments and notifications Use Cases Emergency department patient intake, urgent care prioritization, virtual triage for telehealth Customization Modify triage agent prompts to reflect your clinical protocols, adjust priority scoring algorithms Benefits Accelerates triage processing by 60%, ensures standardized clinical assessment

Automate your cold email outreach with this 3-stage workflow that sends emails, triggers follow-ups after 3 days, and syncs responses to HubSpot CRM automatically. Uses:** n8n, Postgres/Supabase, Resend API, HubSpot Features:** Scheduled triggers, automatic follow-ups, response tracking via webhooks, CRM auto-sync Perfect for sales teams and marketers who want to scale outreach without manual work. 📺 Full tutorial included 📧 Questions? Need customization? Connect with me on LinkedIn: Click here 👀 Check out my other automation workflows on my n8n creator profile for more productivity tools!

Workflow Name: 💬 Demo Call Back Template was created in n8n v1.90.2 Skill Level: High Categories: n8n, Chatbot Stacks Execute Sub-workflow Trigger node Chat Trigger node Redis node Postgres node Telegram node HTTP Request node If node, Code node, Edit Fields (Set) Prerequisite Execute Sub-workflow Trigger: your own node MiniMax Account (https://www.minimax.io/) Production Features Scaling Design* for n8n Queue mode* in production environment Optional Provider Data from external Database with Caching Mechanism. Optional AI Clone Voice Message response via MiniMax API with Multi-Languages support. Optional Backup Chat Log to Database, so you can use in APP/API building. Testing Flow** with or without dependance on other workflow. Multi Chatbot** (This is a demo for Telegram, you can add WhatsApp, Line, etc) Error Management** What this workflow does? This is a n8n Telegram Output Workflow. It will receive message from other Sub-workflow then output to Telegram for Message, or Replay Message and extra Voice Message. How it works The Flow Trigger node will wait for the message from other Sub-workflow. When message is received, it will first check for the matching Provider from the PostgreSQL database. Then determine if it is a Voice message to Text message. OPTIONAL. For voice message, use the MiniMax API to generate a voice message, then send it to Telegram. Finally, send the text to Telegram. Set up instructions Pull and Set up the required SQL from our Github repository. Create you Redis credentials, refer to n8n integration documentation for more information. Select your Credentials in Provider Cache and Save Provider Cache. Create you Postgres credentials, refer to n8n integration documentation for more information. Select your Credentials in Load Member Data, Create Chat Log Input, and Create Chat Log Output. Create you Telegram credentials, refer to n8n integration documentation for more information. Select your Credentials in Telegram Voice Output, Telegram Reply Output, and Telegram Output. AI Clone Voice setup instructions (Optional) You can clone any voice with MiniMax Go to https://www.minimax.io/ and create a MiniMax account Setup the Database with the required variables found in the MiniMax TTS node That’s it How to adjust it to your needs By default, this template will use the sys_provider table provider information, you could change it for your own design. The demo use MiniMax API for AI voice cloning, you could implement any other AI your choice. The Backup Chat Log will backup all chat conversion line by line. You can use it for you own APP/API development.

Stop manually checking dozens of career pages. This workflow runs every morning, hits the public APIs of 8+ ATS platforms and job boards, normalizes every listing into a single clean schema, and syncs everything to Supabase and Google Sheets deduplicated and ready to query. Who it's for Job seekers, recruiters, or career platforms that want a consolidated, up-to-date feed of openings from specific companies without scraping, without API keys, and without paying for a jobs aggregator. How it works A Schedule Trigger fires daily at 8 AM IST A Company List code node defines all sources grouped by ATS type (Greenhouse, Lever, Ashby, Workable, SmartRecruiters, RemoteOK, and board APIs like Remotive, Himalayas, Arbeitnow, Jobicy) A Prepare Request node builds the correct API URL and headers for each source, including multi-page pagination for SmartRecruiters (up to 500 jobs via offset) and Himalayas (up to 500 via page param) An HTTP Request node fetches all sources in batches of 5 A Parse + Enrich + Filter node normalizes all divergent JSON structures into a unified schema — resolving ISO country codes, Indian city detection, salary parsing across all formats, and domain-based filtering Deduplicated results are upserted to a Supabase (Postgres) table and written to Google Sheets ATS platforms supported Greenhouse, Lever, Ashby, Workable, SmartRecruiters, RemoteOK, Remotive, Himalayas, Arbeitnow, Jobicy Normalized output schema job_id, title, company, location, country, salary, job_type, apply_url, posted_at, source_ats Setup Open the Company List node and edit the sources array — add or remove companies and their ATS slugs Update ALLOWED_DOMAINS in the Parse node to filter by location or job type relevant to you Add your Supabase credentials in the Postgres node and confirm your table name and schema match the output fields Connect your Google Sheets credentials and set the target spreadsheet and sheet ID (Optional) Adjust pagination limits per source in the Prepare Request node Requirements Self-hosted or cloud n8n instance Supabase project with a jobs table Google Sheets with headers matching the normalized schema No external API keys required — all sources use public endpoints

Keep your job listings database clean without manual checks. Every three days, this workflow fetches all active jobs from your Postgres database, runs each application URL through a validation check, identifies dead links via HTTP status codes and soft-404 redirect detection, then marks failed entries as inactive in both Supabase and Google Sheets simultaneously. Who it's for Teams running a job aggregator, career platform, or internal hiring tracker who store job listings in Postgres and want stale or broken apply links removed automatically — without waiting for user reports. How it works A Schedule Trigger fires every 3 days All active jobs are fetched from your Postgres (Supabase) database via a SQL query A Prepare URLs node filters out any rows with missing, malformed, or non-HTTP URLs before they're checked An HTTP Request node sends a HEAD request to each apply_url A Find Dead Jobs code node analyzes each response and flags a job as dead if: Status code is 404 or 410 DNS resolution fails (ENOTFOUND) Connection is refused (ECONNREFUSED) A 301/302/307 redirect points to a different path — indicating the job was removed and the ATS is silently redirecting (soft-404 detection) If dead jobs are found, an IF node routes them to both update nodes in parallel: Supabase (Postgres) — status set to inactive via parameterized SQL Google Sheets — row updated to reflect the new status If no dead jobs are detected, the workflow exits cleanly with no writes Setup Connect your Postgres credentials and confirm the query in the Fetch Active Jobs node matches your table and column names (apply_url, job_hash, job_title) Connect your Google Sheets credentials and set the Resource ID and Sheet Name in the Mark Inactive node Confirm the inactive status value in the Postgres update query matches what your app expects (Optional) Adjust the soft-404 redirect detection logic in the Find Dead Jobs node if your ATS platforms use non-standard redirect patterns Database columns expected job_hash (unique identifier), apply_url, job_title, status Requirements Self-hosted or cloud n8n instance Supabase (or any Postgres-compatible) database with an active jobs table Google Sheets with a matching jobs log

Keep your job listings database clean without manual checks. Every three days, this workflow fetches all active jobs from your Postgres database, runs each application URL through a validation check, identifies dead links via HTTP status codes and soft-404 redirect detection, then marks failed entries as inactive in both Supabase and Google Sheets simultaneously. Who it's for Teams running a job aggregator, career platform, or internal hiring tracker who store job listings in Postgres and want stale or broken apply links removed automatically — without waiting for user reports. How it works A Schedule Trigger fires every 3 days All active jobs are fetched from your Postgres (Supabase) database via a SQL query A Prepare URLs node filters out any rows with missing, malformed, or non-HTTP URLs before they're checked An HTTP Request node sends a HEAD request to each apply_url A Find Dead Jobs code node analyzes each response and flags a job as dead if: Status code is 404 or 410 DNS resolution fails (ENOTFOUND) Connection is refused (ECONNREFUSED) A 301/302/307 redirect points to a different path — indicating the job was removed and the ATS is silently redirecting (soft-404 detection) If dead jobs are found, an IF node routes them to both update nodes in parallel: Supabase (Postgres) — status set to inactive via parameterized SQL Google Sheets — row updated to reflect the new status If no dead jobs are detected, the workflow exits cleanly with no writes Setup Connect your Postgres credentials and confirm the query in the Fetch Active Jobs node matches your table and column names (apply_url, job_hash, job_title) Connect your Google Sheets credentials and set the Resource ID and Sheet Name in the Mark Inactive node Confirm the inactive status value in the Postgres update query matches what your app expects (Optional) Adjust the soft-404 redirect detection logic in the Find Dead Jobs node if your ATS platforms use non-standard redirect patterns Database columns expected job_hash (unique identifier), apply_url, job_title, status Requirements Self-hosted or cloud n8n instance Supabase (or any Postgres-compatible) database with an active jobs table Google Sheets with a matching jobs log

Stop manually checking dozens of career pages. This workflow runs every morning, hits the public APIs of 8+ ATS platforms and job boards, normalizes every listing into a single clean schema, and syncs everything to Supabase and Google Sheets deduplicated and ready to query. Who it's for Job seekers, recruiters, or career platforms that want a consolidated, up-to-date feed of openings from specific companies without scraping, without API keys, and without paying for a jobs aggregator. How it works A Schedule Trigger fires daily at 8 AM IST A Company List code node defines all sources grouped by ATS type (Greenhouse, Lever, Ashby, Workable, SmartRecruiters, RemoteOK, and board APIs like Remotive, Himalayas, Arbeitnow, Jobicy) A Prepare Request node builds the correct API URL and headers for each source, including multi-page pagination for SmartRecruiters (up to 500 jobs via offset) and Himalayas (up to 500 via page param) An HTTP Request node fetches all sources in batches of 5 A Parse + Enrich + Filter node normalizes all divergent JSON structures into a unified schema — resolving ISO country codes, Indian city detection, salary parsing across all formats, and domain-based filtering Deduplicated results are upserted to a Supabase (Postgres) table and written to Google Sheets ATS platforms supported Greenhouse, Lever, Ashby, Workable, SmartRecruiters, RemoteOK, Remotive, Himalayas, Arbeitnow, Jobicy Normalized output schema job_id, title, company, location, country, salary, job_type, apply_url, posted_at, source_ats Setup Open the Company List node and edit the sources array — add or remove companies and their ATS slugs Update ALLOWED_DOMAINS in the Parse node to filter by location or job type relevant to you Add your Supabase credentials in the Postgres node and confirm your table name and schema match the output fields Connect your Google Sheets credentials and set the target spreadsheet and sheet ID (Optional) Adjust pagination limits per source in the Prepare Request node Requirements Self-hosted or cloud n8n instance Supabase project with a jobs table Google Sheets with headers matching the normalized schema No external API keys required — all sources use public endpoints

Finance Research Analyst for Boutique M&A Agencies This workflow acts as a junior finance research analyst for a UK boutique M&A or corporate finance team. It listens for Slack messages, classifies the request, gathers company or market data, and produces structured outputs in Google Docs, Google Slides, Google Sheets, and PostgreSQL. It supports three user intents: Research this company X Prepare pitch materials for X Industry briefing on vertical X The workflow is designed for internal team use. It is not intended to send client-facing materials automatically without human review. Why This Template This template shows how a junior research analyst LIVE job and some of the key responsibilities might be automated with help of AI. 120+ junior analyst roles are live in London right now. This template does most of what they do. What This Template Does Company Research When a user asks to research a company, the workflow: searches Companies House for the best UK entity match retrieves company profile, officers, and filing history gathers company and website context using Firecrawl retrieves public market quote data from Alpha Vantage when a ticker is available asks an LLM to synthesize the research into a structured company profile creates a Google Doc with the company profile upserts the company into PostgreSQL stores the generated research as reusable memory updates the client database in Google Sheets replies in the original Slack thread with the output link Pitch Materials When a user asks to prepare pitch materials, the workflow: loads the stored company record from PostgreSQL pulls the most recent stored research memory asks an LLM to produce compact slide-ready bullet content copies a Google Slides pitch template replaces the template placeholders with generated content creates a Google Doc press release draft updates the pitch deck URL in PostgreSQL updates the client database in Google Sheets replies in the original Slack thread with the deck and document links Industry Briefing When a user asks for a sector briefing, the workflow: gathers sector web and news context using Firecrawl retrieves ONS macro M&A context asks an LLM to generate a concise one-page industry briefing creates a Google Doc with the briefing replies in the original Slack thread with the document link Who This Is For This template is built for: boutique M&A advisory firms corporate finance teams fundraising advisors internal research analysts supporting pitch and origination work It is optimized for UK company research because it relies on Companies House as the authoritative company registry. Prerequisites Before using this template, you need: an n8n instance a Slack app configured for message triggers and posting replies a Google account with Drive, Docs, Slides, and Sheets access (Free) a PostgreSQL database (Free self hosted or use supabase) an OpenRouter credential for the LLM calls (Models used= haiku4.5, Sonnet 4.5) a Companies House API key configured as Basic Auth (Free) a Firecrawl API key configured as HTTP Header Auth (Free) API key for Alpha Vantage (free) fixed ONS URL for macro M&A context Required n8n Credentials Create or connect the following credentials in n8n before testing: Slack Trigger credential for incoming Slack events Slack credential for posting replies OpenRouter API Companies House Basic Auth Firecrawl Header Auth Google Drive OAuth2 Google Docs OAuth2 Google Slides OAuth2 Google Sheets OAuth2 Postgres Required External Assets Google Drive Root Folder The workflow creates subfolders under a given root folder: research outputs pitch outputs briefing outputs Current root folder used in the workflow: Modify this to your own folder: https://drive.google.com/drive/u/0/folders/1GH-YouAAImKugZ11IbqA6Ouw8B9U17-I Google Sheets Client Database The workflow writes to this spreadsheet: Modify this to your own google sheet: https://docs.google.com/spreadsheets/d/1yJ-UKOEUqIruCv-IBA33oN4taQTB1TA8M4a6D2iSiOU/edit?gid=0#gid=0 Required sheet name: Sheet1 Required columns: company_name sector companies_house_number market_cap last_researched profile_doc_url pitch_deck_url Best practice: make companies_house_number unique if possible keep column names exactly as shown above Google Slides Pitch Template The workflow copies this Slides template: 1zQv_cbafHzd4JNsr711Rm0558O6W_S1SODc-u6tVS0k Required placeholders in text boxes: {company_name} {sector} {profile_summary} {financials} {opportunity_summary} {comps_note} Input Examples Use messages like these in Slack: Research Monzo, fintech Prepare pitch for Wise Industry briefing UK fintech Outputs Research Intent Outputs: Google Doc company profile PostgreSQL company record update PostgreSQL research memory insert Google Sheets client DB update Slack thread reply with doc link Pitch Intent Outputs: copied and populated Google Slides deck Google Doc press release draft PostgreSQL pitch deck URL update Google Sheets client DB update Slack thread reply with deck and doc links Brief Intent Outputs: Google Doc industry briefing Slack thread reply with doc link Database Expectations This template expects PostgreSQL tables to exist for: company records research memory At minimum, your database must support the queries used by the workflow for: upserting company records loading a company record by company_name storing research memory retrieving the latest research memory for pitch generation updating pitch_deck_url Limitations UK company research is strongest because the workflow depends on Companies House. private companies will not have public market quote data public-company quote data comes from Alpha Vantage GLOBAL_QUOTE, which is not a true market-cap endpoint the workflow does not create dynamic charts in Google Slides. the workflow does not replace human judgment on valuation, comps, or client-facing strategy

Overview This workflow captures incoming leads from a webhook, enriches them using AI, and automates the entire sales pipeline. It validates data, scores leads as hot, warm, or cold, assigns them to sales reps, syncs with CRM systems, and triggers notifications and follow-ups. It helps teams respond faster, prioritize high-value leads, and streamline sales operations with minimal manual effort. How It Works Webhook Trigger Captures lead data from forms or landing pages. Workflow Configuration Defines: CRM API endpoint Slack notification channel Sales reps list for assignment Validation Ensures required fields (name and email) are present. Routes invalid submissions to error handling. Data Normalization Structures lead data (name, email, phone, company, message). AI Lead Enrichment Classifies lead as: Hot Warm Cold Generates: Score reasoning Estimated deal value Company insights Recommended next actions Database Storage Stores enriched lead data in Postgres. Sales Assignment Assigns leads using round-robin distribution logic. CRM Integration Sends lead data to CRM (e.g., HubSpot, GoHighLevel) Optionally creates Salesforce leads Automated Communication Sends welcome email to the lead Notifies sales team via Slack Activity Logging Logs all actions for tracking and analytics Setup Instructions Webhook Setup Configure endpoint (lead-capture) Connect your form or frontend OpenAI Credentials Add API key for lead scoring and enrichment Database Setup Configure Postgres credentials Create tables: leads activity_log CRM Integration Add API credentials for your CRM Set endpoint URL Salesforce (Optional) Configure Salesforce credentials if used Slack Integration Add Slack credentials Set channel ID for notifications Email Setup Connect Gmail account for sending emails Configure Sales Reps Add email list in configuration node Use Cases Automated lead qualification for marketing teams SaaS lead management pipelines Agency client acquisition workflows CRM automation with AI enrichment Sales team lead distribution systems Requirements OpenAI API key Postgres database CRM system (HubSpot, GoHighLevel, or similar) Gmail account Slack workspace Salesforce account (optional) n8n instance Key Features AI-powered lead scoring and enrichment Automated validation and error handling Round-robin sales assignment Multi-CRM integration support Real-time Slack notifications Automated email follow-ups Full activity tracking and logging Summary A complete AI-driven lead management system that captures, enriches, scores, and routes leads automatically. It enables faster response times, better lead prioritization, and scalable sales automation for modern teams.

Overview This workflow enables GDPR-compliant document processing by detecting, masking, and securely handling personally identifiable information (PII) before AI analysis. It ensures that sensitive data is never exposed to AI systems by replacing it with tokens, while still allowing controlled re-injection of original values when permitted. The workflow also maintains full audit logs for compliance and traceability. How It Works Document Upload & Configuration Receives documents via webhook and initializes configuration such as document ID, thresholds, and database tables. Text Extraction Extracts raw text from uploaded documents for processing. Multi-Detector PII Detection Detects emails, phone numbers, ID numbers, and addresses using regex and AI-based detection. PII Aggregation & Conflict Resolution Merges detections, resolves overlaps, removes duplicates, and builds a unified PII map. Tokenization & Vault Storage Replaces sensitive data with secure tokens and stores original values in a database vault. Masking & Validation Generates masked text and verifies that all PII has been successfully removed before AI processing. AI Processing (Masked Data) Processes the document using AI while preserving tokens to prevent exposure of sensitive information. Re-Injection Controller Determines which fields are allowed to restore original PII based on permissions. Secure Retrieval & Restoration Retrieves original values from the vault and restores them only where permitted. Audit Logging Stores metadata, detected PII types, and re-injection events for compliance tracking. Error Handling & Alerts Blocks processing and triggers alerts if masking fails or compliance rules are violated. Setup Instructions Activate the webhook and upload a document (PDF or supported file) Configure AI credentials (Anthropic / OpenAI) Set database credentials for PII vault and audit logs Adjust detection thresholds and compliance settings if needed Execute the workflow and review outputs and logs Use Cases GDPR-compliant document processing pipelines Secure AI document analysis with PII protection Automated redaction and tokenization systems Financial, legal, or healthcare document processing Privacy-first AI workflows for sensitive data Requirements n8n (latest version recommended) Anthropic or OpenAI API credentials PostgreSQL (or compatible database) for vault and audit logs Input documents (PDF or text-based files)

Overview This workflow automates bulk email campaigns with built-in validation, deliverability protection, and smart send-time optimization. It processes CSV leads, validates emails, enriches data, and schedules campaigns intelligently. Emails are sent using controlled inbox rotation, while engagement tracking and analytics continuously improve performance. How It Works Campaign Input Receives campaign data and CSV leads via webhook. Lead Processing Extracts CSV data, splits leads, and validates email format. Domain & Quality Checks Verifies domains using MX records and filters invalid leads. Lead Enrichment Adds timezone, domain type, and engagement score for better targeting. Lead Storage Stores valid leads and separates invalid ones for tracking. Campaign Execution Scheduler fetches active campaigns and selects top leads. Send Optimization Calculates best send time per lead based on timezone and historical performance, while selecting inboxes within sending limits. Email Delivery Waits until optimal time and sends emails using selected inbox. Tracking & Logging Logs sent emails and updates inbox usage statistics. Event Tracking Captures opens, clicks, replies, and bounces via webhook. Performance Analytics Updates campaign stats and analyzes engagement trends. Continuous Optimization Updates send-time rules to improve future campaign performance. Setup Instructions Connect webhook for campaign and CSV upload Configure send limits, delays, and MX API Set up Postgres with required tables Connect Gmail or SMTP for sending Configure event webhook for tracking Enable campaign and analytics schedulers Test with sample campaign before activating Use Cases Running cold email campaigns at scale Improving email deliverability and sender reputation Automating lead validation and enrichment Optimizing send times based on engagement data Managing multi-inbox outbound systems Requirements n8n instance with webhook support Postgres database Gmail or SMTP email account(s) MX record lookup API (e.g., Google DNS) Email tracking system or webhook integration Notes Inbox rotation and throttling help prevent spam and protect reputation. Engagement-based lead scoring improves campaign performance. Send-time optimization is continuously refined using real data. You can extend this workflow with personalization or AI-generated emails.

Overview This workflow implements a self-healing Retrieval-Augmented Generation (RAG) maintenance system that automatically updates document embeddings, evaluates retrieval quality, detects embedding drift, and safely promotes or rolls back embedding updates. Maintaining high-quality embeddings in production RAG systems is difficult. When source documents change or embedding models evolve, updates can accidentally degrade retrieval quality or introduce semantic drift. This workflow solves that problem by introducing an automated evaluation and rollback pipeline for embeddings. It periodically checks for document changes, regenerates embeddings for updated content, evaluates the new embeddings against a set of predefined golden test questions, and compares the results with the currently active embeddings. Quality metrics such as Recall@K, keyword similarity, and answer variance are calculated, while embedding vectors are also analyzed for semantic drift using cosine distance. If the new embeddings outperform the current ones and remain within acceptable drift limits, they are automatically promoted to production. Otherwise, the system safely rolls back or flags the update for manual review. This creates a robust, production-safe RAG lifecycle automation system. How It Works Workflow Trigger The workflow can start in two ways: Scheduled trigger** running daily Webhook trigger** when source documents change Both paths lead to a centralized configuration node that defines parameters such as chunk size, thresholds, and notification settings. Document Retrieval & Change Detection Documents are fetched from the configured source (GitHub, Drive, Confluence, or other APIs). The workflow then: Splits documents into deterministic chunks Computes SHA-256 hashes for each chunk Compares them with previously stored hashes in Postgres Only new or modified chunks proceed for embedding generation, which significantly reduces processing cost. Embedding Generation Changed chunks are processed through: Recursive text splitting Document loading OpenAI embedding generation These embeddings are stored as a candidate vector store rather than immediately replacing the production embeddings. Metadata about the embedding version is stored in Postgres. Golden Question Evaluation A set of golden test questions stored in the database is used to evaluate retrieval quality. Two AI agents are used: One queries the candidate embeddings One queries the current production embeddings Both generate answers using retrieved context. Quality Metrics Calculation The workflow calculates several evaluation metrics: Recall@K** to measure retrieval effectiveness Keyword similarity** between generated answers and expected answers Answer length variance** to detect inconsistencies These are combined into a weighted quality score. Embedding Drift Detection The workflow compares embedding vectors between versions using cosine distance. This identifies semantic drift, which may occur due to: embedding model updates chunking changes document structure changes Promotion or Rollback The workflow checks two conditions: Quality score exceeds the configured threshold Embedding drift remains below the drift threshold If both conditions pass: The candidate embeddings are promoted to active If not: The system rolls back to the previous embeddings Or flags the update for human review Notifications A webhook notification is sent with: update status quality score drift score timestamp This allows teams to monitor embedding health automatically. Setup Instructions Configure Document Source Edit the Workflow Configuration node and set: documentSourceUrl API endpoint or file source containing your documents. Examples include: GitHub repository API Google Drive export API Confluence REST API Configure Postgres Database Create the following tables in your Postgres database: document_chunks embeddings embedding_versions golden_questions These tables store chunk hashes, embedding vectors, version metadata, and evaluation questions. Connect the Postgres nodes using your database credentials. Add OpenAI Credentials Configure credentials for: OpenAI Embeddings** OpenAI Chat Model** These are used for generating embeddings and answering evaluation questions. Populate Golden Questions Insert evaluation questions into the golden_questions table. Each record should include: question_text expected passages expected answer keywords These questions represent critical queries your RAG system must answer correctly. Configure Notification Webhook Add a Slack or Teams webhook URL in the configuration node. Notifications will be sent whenever: embeddings are promoted embeddings are rolled back manual review is required Adjust Quality Thresholds In the configuration node you can modify: qualityThreshold driftThreshold chunkSize chunkOverlap These parameters control the sensitivity of the evaluation system. Use Cases Production RAG Monitoring Automatically evaluate and update embeddings in production knowledge systems without risking degraded results. Continuous Knowledge Base Updates Keep embeddings synchronized with frequently changing documentation, repositories, or internal knowledge bases. Safe Embedding Model Upgrades Test new embedding models against production data before promoting them. AI System Reliability Detect retrieval regressions before they affect end users. Enterprise AI Governance Provide automated evaluation and rollback capabilities for mission-critical RAG deployments. Requirements This workflow requires the following services: n8n** Postgres Database** OpenAI API** Recommended integrations: Slack or Microsoft Teams (for notifications) Required nodes include: Schedule Trigger Webhook HTTP Request Postgres Compare Datasets Code nodes OpenAI Embeddings OpenAI Chat Model Vector Store nodes AI Agent nodes Summary This workflow provides a fully automated self-healing RAG infrastructure for maintaining embedding quality in production systems. By combining change detection, golden-question evaluation, embedding drift analysis, and automatic rollback, it ensures that retrieval performance improves safely over time. It is ideal for teams running production AI assistants, knowledge bases, or internal search systems that depend on high-quality vector embeddings.

Self-learning feedback loop for AI customer support email drafts with Gmail, OpenAI and PostgreSQL Automatically compare AI-generated email drafts against what your support team actually sent, learn from the differences, and improve future drafts over time — without any model fine-tuning. What this workflow does This is the second workflow in a two-part customer support automation system. The first workflow generates AI draft replies for incoming support emails. This workflow closes the loop — it runs every 3 hours, checks which drafts were reviewed and sent, compares them against the original AI output, and stores the human-edited versions as training examples. The more this workflow runs, the smarter the first workflow becomes. When generating future drafts, the similarity search surfaces past human-approved responses — so the AI progressively learns what good answers look like for your specific support context. How it works Step 1 — Watermark and scheduling Every run starts by fetching the last_processed_sent_at timestamp from the previous completed run. Only Gmail Sent emails newer than this timestamp are fetched, so nothing gets processed twice. On the first-ever run it defaults to 7 days ago. Step 2 — Fetch and loop Sent emails are fetched from Gmail and processed one at a time. For each email, the full message body is retrieved via the Gmail API (the list endpoint only returns a preview snippet). The sent email's thread ID is matched against the ai_drafts table to find the corresponding AI draft. Step 3 — Match and skip logic Three things skip an email without processing: no matching AI draft found (the team sent something manually), the draft was already processed in a previous run, or the fetch returns no results. Only genuine unprocessed matches continue. Step 4 — AI comparison GPT-4o-mini compares the AI draft text against the human-sent text and returns a structured analysis: whether it was approved unchanged, the type of edit made (minor edits vs major rewrite), a plain English summary of what changed, and whether the edit implies missing or incorrect information in the knowledge base. Step 5 — Store the correction If the human made any edits, the pair (original email + human response) is embedded using OpenAI text-embedding-3-small and saved to the corrections table. This table is what the first workflow searches using vector cosine similarity when assembling future draft prompts. Step 6 — KB auto-update If the AI comparison flags that the human edit contained new information, the most relevant knowledge base entry for that category is fetched and rewritten by GPT-4o-mini to incorporate the new information. The previous answer is preserved in the previous_answer column for auditing. Step 7 — Run log Each run is logged to feedback_run_log with counts of emails checked, corrections saved, KB updates made and any errors. This log also serves as the watermark source for the next run. Setup steps Prerequisites Gmail account (same support inbox used by the main email workflow) OpenAI API key PostgreSQL database with pgvector extension and the full schema from Workflow 1 already applied The main email automation workflow (Workflow 1) must be active and generating drafts Apply the DB migration Run the following against your existing database to add the columns this workflow needs: ALTER TABLE ai_drafts ADD COLUMN IF NOT EXISTS email_embedding vector(1536), ADD COLUMN IF NOT EXISTS feedback_processed_at TIMESTAMPTZ, ADD COLUMN IF NOT EXISTS was_approved_as_is BOOLEAN DEFAULT FALSE; ALTER TABLE corrections ADD COLUMN IF NOT EXISTS source TEXT DEFAULT 'feedback_loop', ADD COLUMN IF NOT EXISTS kb_updated BOOLEAN DEFAULT FALSE; ALTER TABLE kb_data ADD COLUMN IF NOT EXISTS updated_by TEXT DEFAULT 'manual', ADD COLUMN IF NOT EXISTS previous_answer TEXT; CREATE TABLE IF NOT EXISTS feedback_run_log ( id SERIAL PRIMARY KEY, run_started_at TIMESTAMPTZ DEFAULT NOW(), run_completed_at TIMESTAMPTZ, last_processed_sent_at TIMESTAMPTZ, emails_checked INTEGER DEFAULT 0, approved_as_is INTEGER DEFAULT 0, corrections_saved INTEGER DEFAULT 0, kb_updates INTEGER DEFAULT 0, errors INTEGER DEFAULT 0, status TEXT DEFAULT 'running' ); Configure credentials | Node | Credential needed | |---|---| | Gmail - Fetch Sent Emails | Gmail OAuth2 | | Gmail - Fetch Full Message | Gmail OAuth2 (HTTP Request with OAuth) | | All DB nodes | PostgreSQL | | OpenAI Chat Model - Compare | OpenAI API | | AI - Rewrite KB Answer | OpenAI API | | Generate Embedding - Human Sent | OpenAI API | Check node connections The splitInBatches loop node has two outputs — make sure they are connected correctly: Output 0 (loop)** → DB - Match Thread ID Output 1 (done)** → DB - Complete Run Log All branch dead-ends (approved as-is, no KB update, KB updated) should feed back into the loop node's input to advance to the next item. Activate Toggle the workflow to active. It will run automatically on the 3-hour schedule. You can also trigger it manually to test. How it connects to Workflow 1 Once corrections start accumulating in the corrections table, Workflow 1's similarity search (which queries this table using vector cosine distance) will begin surfacing relevant past human-approved responses when assembling draft prompts. No changes to Workflow 1 are needed — it queries the same table this workflow writes to. Tech stack n8n** — workflow automation and scheduling Gmail API** — sent folder monitoring and full message fetch OpenAI GPT-4o-mini** — draft comparison and KB rewriting OpenAI text-embedding-3-small** — vector embedding for similarity search PostgreSQL + pgvector** — storing corrections and running cosine similarity queries Who this is for Teams already running an AI email draft workflow who want it to improve over time Support operations that want human edits to automatically become training data Anyone who wants a self-improving system without model fine-tuning or external ML infrastructure

Overview This workflow implements a privacy-preserving AI document processing pipeline that detects, masks, and securely manages Personally Identifiable Information (PII) before any AI processing occurs. Organizations often need to analyze documents such as invoices, forms, contracts, or reports using AI. However, sending documents containing personal data directly to AI models can create serious privacy, compliance, and security risks. This workflow solves that problem by automatically detecting sensitive information, replacing it with secure tokens, and storing the original values in a protected vault database. Only the masked version of the document is sent to the AI model for analysis. If required, a controlled PII re-injection mechanism can restore original values after processing. The workflow also records all operations in an audit log, making it suitable for environments requiring strong compliance such as GDPR, financial services, healthcare, or enterprise document processing systems. How It Works Document Upload A webhook receives a document (typically a PDF) and triggers the workflow. OCR Text Extraction The OCR Extract node extracts the text content from the document so it can be analyzed for sensitive information. PII Detection Multiple detectors analyze the text to identify different types of sensitive data: Email addresses (regex detection) Phone numbers (multi-pattern detection) Identification numbers such as PAN, SSN, or bank accounts Physical addresses detected using an AI model Each detection includes: detected value location in the text confidence score Detection Consolidation All detected PII results are merged into a single dataset. The workflow resolves overlapping detections and removes duplicates to produce a clean list of sensitive values. Tokenization and Secure Vault Storage Each detected PII value is replaced with a secure token, for example: <<EMAIL_7F3A>> <<PHONE_A12B>> The original values are securely stored in a Postgres vault table. This ensures sensitive data is never exposed to AI models. Masked AI Processing The masked document is sent to an AI model for structured analysis. Possible AI tasks include: Document classification Data extraction Document summarization Entity extraction Since all sensitive data has been tokenized, the AI processes the document without seeing any real personal data. Controlled PII Re-Injection After AI processing, the workflow can optionally restore original values from the vault. The Re-Injection Controller determines which fields are allowed to restore PII based on defined permissions. Compliance Audit Logging All events are recorded in an audit table, including: PII detection token generation AI processing PII restoration This provides traceability and compliance reporting. Setup Instructions Configure Postgres Database Create two tables in your database. PII Vault Table Example structure: token original_value type document_id created_at This table securely stores original PII values mapped to tokens. Audit Log Table Example structure: document_id pii_types_detected token_count ai_access_confirmed re_injection_events timestamp actor This table records workflow activity for compliance tracking. Configure AI Model Credentials This workflow supports multiple AI models: Anthropic Claude (used for AI document processing) Ollama local models (used for address detection) Configure credentials in n8n before running the workflow. Configure Webhook Trigger The workflow starts when a document is sent to the webhook: POST /webhook/gdpr-document-upload Upload a PDF file to this endpoint to trigger processing. Configure Alert Notifications (Optional) Replace the placeholder alert webhook URL with your monitoring or alerting system. Example use cases: Slack alert monitoring system incident notification Alerts are triggered if masking fails. Use Cases This workflow is useful for many privacy-sensitive automation scenarios. GDPR-Compliant Document Processing Safely process documents containing personal data without exposing PII to AI models. AI-Powered Document Analysis Use AI to summarize or extract data from documents while maintaining privacy. Enterprise Data Redaction Pipelines Automatically detect and tokenize sensitive data before sending documents to downstream systems. Financial Document Processing Process invoices, contracts, and financial reports securely. Healthcare Document Automation Analyze patient documents while ensuring sensitive data is protected. Requirements To run this workflow you need: n8n** Postgres database** Anthropic Claude API access** Ollama (optional for local AI address detection)** Webhook endpoint for document uploads** Optional integrations: Monitoring or alert system Compliance audit database Key Features Automated PII detection and tokenization AI-safe document processing** Secure vault storage for sensitive data Controlled PII restoration Full audit logging Works with multiple AI models Designed for GDPR and enterprise compliance Summary This workflow creates a secure bridge between sensitive documents and AI systems. By automatically detecting, masking, and securely storing personal data, it enables organizations to safely apply AI to document processing tasks without exposing sensitive information. The combination of tokenization, secure vault storage, controlled re-injection, and audit logging makes this workflow suitable for privacy-sensitive industries and enterprise automation pipelines.

This n8n workflow automates the transformation of raw text ideas into structured visual diagrams and content assets using NapkinAI. It connects Claude AI (Anthropic) with NapkinAI to take any rough concept or unstructured idea, intelligently enrich and structure it, generate polished visual diagrams, and deliver the results directly to your team via email, Slack, and a database log — all hands-free. 🔄 Workflow Stages Input Collection Webhook trigger accepts raw idea text Manual trigger for testing Configurable idea metadata (title, type, audience) AI Idea Enrichment (Claude) Expands raw idea into structured concept Extracts key themes and relationships Suggests optimal diagram types Generates multiple visual concepts NapkinAI Processing Authenticate with NapkinAI API Submit enriched text for visual generation Poll for completion status Retrieve generated diagram assets Asset Management Download generated visuals Store metadata in database Organize by project/category Delivery Email with visual assets attached Slack notification with preview Save to Google Drive / Notion ⚙️ Setup Required NapkinAI API credentials Anthropic API key (Claude) SMTP for email delivery Slack webhook (optional) PostgreSQL for logging (optional) Why Does It Matter? Creating visual content is time-consuming. Turning an idea into a diagram, infographic, or visual asset typically requires: Writing a clear brief Choosing the right diagram format Using design tools manually Iterating on structure and layout This workflow compresses all of that into a single automated pipeline. Key benefits: Speed: Ideas become visuals in minutes, not hours Consistency: Every output follows a structured process Scale: Process multiple ideas simultaneously Repurposing: Each idea generates 3+ content format suggestions Team Visibility: Slack + email notifications keep everyone aligned Tracking: Database logging enables analytics over time

This n8n workflow runs daily to analyze active customer behavior, engineers relevant features from usage and transaction data, applies a machine learning or AI-based model to predict churn probability, classifies risk levels, triggers retention actions for at-risk customers, stores predictions for tracking, and notifies relevant teams. Key Insights Prediction accuracy heavily depends on feature quality — ensure login frequency, spend trends, support interactions, and engagement metrics are consistently captured and up-to-date. Start with simple rule-based scoring or AI prompting (e.g., OpenAI/Claude) before integrating full ML models for easier testing and faster value. High-risk thresholds (e.g., >70%) should be tuned based on your actual churn data to avoid alert fatigue or missed opportunities. Workflow Process Initiate the workflow with the Daily Schedule Trigger node (runs every day at 2 AM). Query the customer database to fetch active user profiles, recent activity logs, login history, transaction records, and support ticket data. Perform feature engineering: calculate metrics such as login frequency (daily/weekly), average spend, spend velocity, days since last activity, number of support tickets, NPS/sentiment if available, and other engagement signals. Feed engineered features into the prediction step: call an ML model endpoint, run a Python code node with a lightweight model, or use an AI agent/LLM to estimate churn probability (0–100%). Classify each customer into risk tiers: HIGH RISK, MEDIUM RISK, or LOW RISK based on configurable probability thresholds. For at-risk customers (especially HIGH), trigger retention actions: create personalized campaigns, add to nurture sequences, generate discount codes, or create tasks in CRM. Store predictions, risk scores, features, and actions taken in an analytics database for historical tracking and model improvement. Send summarized alerts (e.g., list of high-risk customers with scores and recommended actions) via Email and/or Slack to customer success or retention teams. Usage Guide Import the workflow into n8n and configure credentials for your customer database (PostgreSQL/MySQL), ML API (if external), analytics DB, Slack webhook, SMTP/email, and CRM/retention platform. Define feature extraction queries and thresholds carefully in the relevant nodes — test with a small customer subset first. If using AI/LLM for prediction, refine the prompt to include clear examples of churn signals. Run manually via the Execute workflow button with sample data to validate data flow, scoring logic, and notifications. Once confident, activate the daily schedule. Prerequisites Customer database with readable tables for users, activity logs, transactions, and support interactions ML integration option: either an external ML API endpoint, Python code node with scikit-learn/simple model, or LLM node (OpenAI, Claude, etc.) for probabilistic scoring Separate analytics database (or same DB) with a table ready for churn predictions (customer_id, date, churn_prob, risk_level, etc.) SMTP credentials or email service for alerts Slack webhook URL (optional but recommended for team notifications) CRM or marketing automation API access (e.g., HubSpot, ActiveCampaign, Klaviyo) for creating retention campaigns/tasks Customization Options Adjust the daily trigger time or make it hourly for near real-time monitoring of high-value accounts. Change risk classification thresholds or add more tiers in the scoring logic node. Enhance the prediction step: switch from LLM-based to a trained ML model (via Hugging Face, custom endpoint, or Code node). Personalize retention actions: use AI to generate custom email content/offers based on the customer's behavior profile. Add filtering (e.g., only high-value customers > certain MRR) to focus retention efforts. Extend notifications: integrate with Microsoft Teams, Discord, or create tickets in Zendesk/Jira for follow-up. Build feedback loop: after actual churn occurs, update a training dataset or adjust weights/rules in future runs.

This n8n workflow automatically fetches monthly financial statements, normalizes the data, performs KPI calculations and trend analysis, detects anomalies, generates AI-powered executive insights and recommendations, creates professional reports, and distributes them to stakeholders while maintaining historical records. Key Insights Consistent data formats from accounting systems (QuickBooks, Xero, etc.) are critical for reliable normalization and analysis. AI-generated insights are only as good as the input data quality — always validate fetched statements and mappings first. Monthly scheduling ensures timely reporting; consider adding manual triggers for ad-hoc runs during testing. Workflow Process Initiate the workflow with the Monthly Schedule Trigger node (runs on the 1st of each month at 8 AM). Fetch current period financial statements (P&L, balance sheet, cash flow) using the accounting API nodes. Fetch previous period data for accurate YoY/MoM comparisons. Merge all statements, normalize formats, validate integrity, and calculate standardized KPIs/metrics using data transformation nodes. Analyze trends, variances, and detect anomalies/unusual patterns. Send cleaned financial data to an AI model (OpenAI/Claude) to generate natural language executive summaries, key insights, and actionable management recommendations. Format and generate professional HTML/PDF reports (with charts/visualizations if configured). Store the report and metrics in a database for historical tracking, post summary to Slack, and email the full report to management/stakeholders. Usage Guide Import the workflow into n8n and configure credentials for your accounting system(s), AI provider, database, Slack webhook, and email (SMTP). Map fields correctly in the normalization/validation nodes to match your source data structure. Test end-to-end with sample/historical financial data before enabling the schedule. Execute manually first via the Execute workflow button to verify each step (especially API fetches and AI output quality). Prerequisites API access to accounting system (QuickBooks, Xero, SAP, or direct database connection) OpenAI or Claude API key for insight generation Database (PostgreSQL, MySQL, etc.) with tables ready for reports and metrics storage SMTP server or email service credentials Slack webhook (optional for notifications) PDF/HTML generation tools (if using external services like WeasyPrint via code node or Make.com-style nodes) Customization Options Adjust the schedule (e.g., quarterly instead of monthly) in the trigger node. Modify the AI prompt in the LLM node to change the style/tone of summaries or add specific focus areas (e.g., cost control, revenue growth). Extend anomaly detection rules or add more KPIs in the analysis section. Change distribution channels (add Teams, Discord, Google Drive upload, etc.) by modifying or adding nodes after report generation. Add conditional branching for high-priority alerts (e.g., if major anomaly detected → immediate notification).

Analyzes influencer profiles and scores authenticity before brand partnership approval. Detects fake followers, bot accounts, and suspicious engagement patterns using AI-powered behavioral analysis. 🎯 How It Works Simple 7-Node Workflow: Input → Submit influencer username and platform (Instagram/Twitter/TikTok) Fetch → Retrieve complete profile data and engagement metrics Analyze → Examine follower patterns, ratios, growth velocity, engagement AI Check → Deep behavioral analysis with Claude AI Report → Generate comprehensive fraud assessment Notify → Send detailed email report to partnership team Log → Save to database for tracking 📊 Detection Capabilities Follower Authenticity**: Analyzes follower-to-following ratio (red flag if < 0.5) Engagement Quality**: Calculates engagement rate (industry avg: 1-5%) Growth Patterns**: Detects suspicious rapid follower spikes Content Consistency**: Evaluates posting frequency and regularity Profile Completeness**: Checks verification, bio, activity AI Behavioral Analysis**: Deep pattern recognition for sophisticated fraud ⚙️ Setup Instructions Configure API Access Social Platform APIs: Instagram**: Get Graph API access token from Meta for Developers Twitter**: OAuth 2.0 credentials from Twitter Developer Portal TikTok**: Business API credentials (optional) AI Analysis: Anthropic Claude API**: Get key from console.anthropic.com Used for advanced behavioral fraud detection Setup Notifications Configure SMTP in "Send Report" node Update recipient email ([email protected]) Customize HTML template if needed Database (Optional) Create PostgreSQL table (schema below) Add database credentials to final node Skip if you don't need historical tracking Database Schema CREATE TABLE partnerships.influencer_fraud_reports ( id SERIAL PRIMARY KEY, report_id VARCHAR(255) UNIQUE, username VARCHAR(255), platform VARCHAR(50), profile_url TEXT, followers BIGINT, following BIGINT, posts INTEGER, verified BOOLEAN, authenticity_score INTEGER, risk_level VARCHAR(50), final_decision TEXT, partnership_recommendation VARCHAR(100), ai_verdict VARCHAR(50), ai_confidence VARCHAR(20), red_flags JSONB, fake_follower_estimate VARCHAR(20), detailed_analysis JSONB, created_at TIMESTAMP ); 🚀 How to Use Webhook Endpoint: POST /webhook/influencer-fraud-check Request Body: { "username": "influencer_handle", "platform": "instagram" // or "twitter", "tiktok" } Example: curl -X POST https://your-n8n.com/webhook/influencer-fraud-check \ -H "Content-Type: application/json" \ -d '{"username":"example_user","platform":"instagram"}' 📈 Scoring System Overall Authenticity Score (0-100): 80-100**: LOW RISK → Approved for partnership 60-79**: MEDIUM RISK → Requires manual review 40-59**: HIGH RISK → Caution advised 0-39**: CRITICAL RISK → Rejected Weighted Components: Follower Quality (25%) Engagement Quality (35%) Content Consistency (15%) Growth Pattern (15%) Profile Completeness (10%) Final Score = 70% Automated + 30% AI Analysis 🚩 Red Flags Detected Following-to-follower ratio > 2:1 Engagement rate < 0.5% Rapid growth (>50K followers/month) Large following with <10 posts No verification with >100K followers Bot-like comment patterns Suspicious audience demographics 💰 Cost Estimate Instagram/Twitter API**: Free tier usually sufficient Claude AI**: ~$0.10-0.20 per analysis Estimated**: $5-10/month for 50 checks 💡 Best Practices Always verify HIGH and MEDIUM risk profiles manually Cross-reference with other influencer databases Request media kit and past campaign results Trial campaigns before large commitments Monitor performance metrics post-partnership Update detection thresholds based on your findings 🎯 What You Get Detailed Report Includes: Overall authenticity score (0-100) Risk level classification Partnership recommendation (APPROVE/REVIEW/REJECT) Engagement quality analysis Fake follower percentage estimate AI behavioral insights Specific red flags and concerns Next steps and recommendations

Automatically discovers trending topics in your niche and generates ready-to-use content ideas with AI. 🎯 How It Works Multi-Source Trend Monitoring Twitter/X trending topics and hashtags Reddit hot posts from niche subreddits Google Trends daily search trends Runs every 2 hours for fresh opportunities Smart Filtering & Scoring Filters by your niche keywords Removes duplicates across sources Calculates viral potential score (0-100) Ranks by engagement, recency, and relevance Prevents suggesting already-covered topics AI Content Generation Uses Claude AI to analyze each trend Generates 5 unique content ideas per trend Provides hooks, key points, and platform recommendations Explains why each idea has viral potential Comprehensive Delivery Beautiful HTML email digest with all opportunities Slack summary for quick review Database logging for tracking Research links for deeper investigation ⚙️ Configuration Guide Step 1: Configure Your Niche Edit the "Load Niche Config" node: niche: 'AI & Technology', // Your industry keywords: [ // Topics to track 'artificial intelligence', 'machine learning', 'AI tools', // Add your keywords ], subreddits: 'artificial+machinelearning', // Relevant subreddits thresholds: { minTwitterLikes: 1000, // Minimum engagement minRedditUpvotes: 500, minComments: 50 } Step 2: Connect Data Sources Twitter/X API: Sign up for Twitter Developer Account Get API credentials (OAuth 2.0) Add credentials to "Fetch Twitter/X Trends" node Reddit API: Create Reddit app: https://www.reddit.com/prefs/apps Get OAuth credentials Add credentials to "Fetch Reddit Hot Topics" node Google Trends: No authentication needed (public API) Already configured in workflow Step 3: Configure AI Integration Anthropic Claude API: Get API key from: https://console.anthropic.com/ Add credentials to "AI - Generate Content Ideas" node Alternative: Use OpenAI GPT-4 by modifying the node Step 4: Setup Notifications Email: Configure SMTP in "Send Email Digest" node Update recipient email address Customize HTML template if desired Slack: Create incoming webhook: https://api.slack.com/messaging/webhooks Add webhook URL to "Send Slack Summary" node Customize channel name Step 5: Database (Optional) Create PostgreSQL database with schema below Add credentials to "Log to Content Database" node Skip if you don't need database tracking Database Schema CREATE TABLE content.viral_opportunities ( id SERIAL PRIMARY KEY, opportunity_id VARCHAR(255) UNIQUE, detected_at TIMESTAMP, topic TEXT, source VARCHAR(50), source_url TEXT, engagement BIGINT, viral_score INTEGER, opportunity_level VARCHAR(20), niche VARCHAR(100), content_ideas JSONB, research_links JSONB, urgency TEXT, status VARCHAR(50), created_at TIMESTAMP DEFAULT NOW() ); 🎨 Customization Options Adjust Scan Frequency Edit "Every 2 Hours" trigger: More frequent: Every 1 hour Less frequent: Every 4-6 hours Consider API rate limits Tune Viral Score Algorithm Edit "Calculate Viral Potential Score" node: Adjust engagement weight (currently 40%) Change recency importance (currently 30%) Modify threshold in "Filter High Potential Only" (currently 40) Customize Content Ideas Modify the AI prompt in "AI - Generate Content Ideas": Change number of ideas (currently 5) Add specific format requirements Include brand voice guidelines Target specific platforms 📊 Expected Results Typical scan finds: 5-15 opportunities** per scan (2 hours) 3-5 HIGH priority** (score 75+) 25+ content ideas** generated Email sent** with full digest Slack alert** for quick review 💡 Pro Tips Timing Matters: Create content within 24-48 hours of detection High Priority First: Focus on opportunities scoring 75+ Platform Match: Choose platforms where your audience is active Add Your Voice: Use AI ideas as starting points, not final copy Track Performance: Note which opportunity types perform best Refine Keywords: Regularly update your niche keywords based on results Mix Formats: Try different content formats for same trend 🚨 Important Notes ⚠️ API Rate Limits: Twitter: Monitor rate limits closely Reddit: 60 requests per minute Claude AI: Tier-based limits Consider caching results 💰 Cost Considerations: Twitter API: May require paid tier Reddit API: Free for reasonable use Claude AI: ~$0.50-1.00 per scan Total: ~$15-30/month estimated 🎯 Best Practices: Start with 1-2 sources, add more later Test with broader keywords initially Review first few reports to tune scoring Don't create content for every opportunity Quality over quantity 🔄 What Happens Next? Workflow runs every 2 hours Scans Twitter, Reddit, Google Trends Filters by your keywords Scores viral potential Generates AI content ideas Sends digest to email + Slack Logs to database Marks topics as suggested Repeat!

This n8n template monitors your self-hosted apps for new releases across GitHub and container registries, uses Claude AI to analyze changelogs, and delivers color-coded update digests to Discord, Telegram, Slack, and ntfy. Stop finding out about updates after something breaks. Claude reads every changelog and tells you exactly what changed, what might break, and how urgent the update is — with a ready-to-run Docker update command for each release. Good to know Estimated cost is $0.01–0.03 per daily run using Claude Haiku. See Anthropic pricing for current rates. PostgreSQL logging is included but optional — the core workflow runs without a database using n8n's built-in static data for version tracking. Test mode is ON by default. Your first run pushes a sample release through the full pipeline (AI analysis, formatting, delivery) so you can verify everything works before going live. How it works Schedule trigger runs daily at 8 AM and builds a watchlist from your manually configured repos plus optional docker-compose auto-detection Checks GitHub Releases API for repos and Docker Hub/GHCR tag APIs for container images. Pre-releases and RC/beta tags are automatically filtered out Compares each release against the last known version stored in workflow static data to detect what's genuinely new Claude Haiku reads each changelog and returns a structured summary with breaking change detection, CVE/security scanning, migration steps, and urgency classification (critical/recommended/optional) Alert rules route critical and security updates to instant alerts, while everything else batches into a single daily digest sorted by urgency Formatted messages are delivered to your enabled channels with color-coded embeds, Docker update commands, and links to full release notes Release history is optionally logged to PostgreSQL for tracking update timelines How to use Add your Anthropic API key as an n8n credential, open the Configure Watcher node to set your channel URLs, and edit the Build Repo Watchlist node to add your repos — that's the minimum to get running Click "Test workflow" to push a sample release through the full pipeline and verify delivery Set test_mode to false and toggle Active — the workflow checks daily and only alerts when new releases are found Requirements Anthropic API key (setup guide) At least one delivery channel: Discord webhook (setup guide), Telegram bot, Slack app, or ntfy topic Optional: GitHub Personal Access Token for higher API rate limits (setup guide) Optional: PostgreSQL for release history logging Customizing this workflow Add or remove repos and container registries in the Build Repo Watchlist code node — pre-loaded with 10 popular self-hosted apps Enable docker-compose auto-detection to automatically build your watchlist from a compose file URL or pasted content Set per-repo alert rules including urgency overrides, instant alert flags, and channel routing Adjust the schedule, swap delivery channels, or add additional registries

Automatically detects new GitHub Pull Requests, analyzes changed code with AI, generates detailed review comments (quality, security, performance, best practices), posts suggestions back to the PR, stores results in a database, and sends notifications. Good to Know Triggers automatically on new/updated GitHub Pull Requests via webhook (or manual test) Fetches only changed files/diffs — no need to clone full repo Uses AI (Grok, OpenAI, Claude, Gemini, etc.) to provide intelligent, context-aware feedback Covers multiple dimensions: code quality, bugs, security vulnerabilities, performance issues, maintainability, style/best practices Posts formatted review comments directly on the GitHub PR (with severity levels, suggestions, code snippets) Stores review history & scores in PostgreSQL (or other DB) for auditing, metrics, team dashboards Sends real-time notifications (Slack, Discord, email, etc.) for high-severity findings Saves developers hours on initial reviews and catches issues early How It Works Trigger PR Detection GitHub Webhook** node — listens for pull_request events (opened, synchronize, reopened, ready_for_review) Optional: Filter node to ignore drafts, dependabot PRs, or specific branches Manual trigger available for testing Fetch & Analyze Code GitHub** node — retrieves PR details (title, body, number, repo, base/head commits) GitHub* or HTTP Request* — fetches list of changed files + diffs (using GitHub API /pulls/{number}/files and diff content) Merge PR Details & Extract Diffs** — combines metadata + code changes into structured format Prepares payload: file paths, diff hunks, full file content if needed (truncated for large files) AI Review & Score Sends prepared diff data + context (language, repo conventions, custom guidelines) to AI model Prompt engineering focuses on: Code correctness & bugs Security vulnerabilities (OWASP, secrets, injection risks) Performance optimizations Readability, maintainability, SOLID principles Best practices & style (specific to language/framework) Refactoring suggestions with examples AI returns structured output: severity (low/medium/high/critical), category, comment text, suggested fix (with code block) Optional: Score node — assigns overall PR quality score (0–100) based on findings Post Review & Notify Route** by severity / issue count (e.g. critical → immediate Slack) GitHub** node — posts detailed review comments on the PR (as bot user) Supports threaded replies, line-specific comments (if hunk positions available) Adds label e.g. ai-reviewed, needs-changes Store Results in PostgreSQL** — logs full review (PR link, timestamp, AI output JSON, score, issues list) Send Summary to Slack** (or Discord/Email/Telegram) — concise message with key findings, link to PR, severity highlights Log Completion** — records successful execution for monitoring Data Sources GitHub** — Pull Requests, diffs, comments, labels (via webhook + API) AI Model** — Grok (xAI), OpenAI GPT-4o / o1, Anthropic Claude, Google Gemini, or local LLM Storage** — PostgreSQL (recommended for structured querying), or Supabase, Airtable, Google Sheets Notifications** — Slack, Discord, Microsoft Teams, Email (SMTP), Telegram How to Use Import the workflow JSON into your n8n instance Configure credentials: GitHub OAuth / Personal Access Token (with repo scope) AI provider API key (Grok/OpenAI/etc.) PostgreSQL database connection Slack/Discord/Email credentials Set up GitHub Webhook: In repo Settings → Webhooks → Add webhook Payload URL = your n8n webhook URL Content type: application/json Events: Pull requests Customize AI prompt — add repo-specific rules, coding standards, ignored patterns Tune filters — minimum severity to post, files to skip (e.g. lock files, generated code) Test — create/open a small PR or use Execute Workflow with sample payload Activate — turn on the workflow and monitor Executions + Logs Requirements n8n (self-hosted preferred for webhooks) GitHub repo with admin access to add webhook & bot token AI API access with sufficient token limit (large PRs = large prompts) PostgreSQL database (or alternative) for persistent storage Notification service account (Slack app, Discord bot, etc.) Customizing This Workflow Add custom best practices** — load from Google Sheets/Notion/Airtable and inject into prompt Support multi-file analysis** — chunk very large PRs or summarize per-file first Auto-approve low-risk PRs** — add approval action if score > 90 and no critical issues Security focus** — integrate with tools like Semgrep/Trivy results Comment on specific lines** — use GitHub API position/hunk data for inline comments Team routing** — notify language-specific experts via Slack channels Metrics dashboard** — connect DB to Grafana/Metabase for review trends Ignore patterns** — skip vendor/, node_modules/, tests/, etc. Multiple AI models** — fallback or ensemble (e.g. Claude for reasoning + Grok for speed)

Creates an AI-powered sales and support agent connected to live store data from Shopify/WooCommerce. MCP ensures controlled access to inventory and order systems. Automatically handles customer queries, stock alerts, and refund logic to reduce manual workload. How it works Trigger — Listens for incoming customer support requests via Webhook (chat, email, or API) Fetch context — Retrieves live order status and inventory data from Shopify in parallel AI reasoning — Claude AI analyzes the query with full store context and decides action Route intent — Classifies into: Order Inquiry, Inventory Check, Refund Request, or General Support Act — Processes refunds, sends stock alerts, or responds to customer automatically Log & notify — Saves interaction to PostgreSQL and notifies team via Slack for escalations Setup steps Shopify / WooCommerce — Add your store API credentials to the HTTP Request nodes Claude AI — Set your Anthropic API key in the AI node credentials PostgreSQL — Create a support_interactions table to log all AI-handled tickets Slack — Add your incoming webhook URL to the Slack notification node Email — Configure SMTP credentials for customer-facing response emails Test — Send a test webhook payload, verify all branches, then activate Intent branches the AI handles: ORDER_INQUIRY → Tracks shipment, shows order details REFUND_REQUEST → Auto-processes eligible refunds via Shopify API INVENTORY_CHECK → Detects low-stock (≤5 units) and fires Slack alert PRICING_INQUIRY / GENERAL_SUPPORT → Smart contextual response Before activating, update these placeholders: YOUR-STORE.myshopify.com + YOUR_SHOPIFY_ACCESS_TOKEN YOUR_SLACK_WEBHOOK_URL (appears in 3 nodes) SMTP credentials + [email protected] PostgreSQL credentials (create a support_interactions table) Explore More LinkedIn & Social Automation: Contact us to design AI-powered lead nurturing, content engagement, and multi-platform reply workflows tailored to your growth strategy.

This n8n template builds an automated daily news digest powered by Claude AI. It monitors RSS feeds, Reddit, and Hacker News, extracts full article text, analyzes each piece with AI, and delivers a polished briefing to Discord and Slack. Stop drowning in newsletters -- Claude reads everything and surfaces only what matters, scored and ranked by importance. Good to know Estimated cost is $0.03-0.10 per daily run using Claude Haiku + Sonnet. See Anthropic pricing for current rates. Works without a database out of the box. Optionally enable PostgreSQL for article history and cross-day deduplication. How it works Schedule trigger fires daily and fetches articles from 10 configurable sources (RSS, Atom, Reddit JSON, Hacker News API) Articles are deduplicated by URL hash and fuzzy title matching Jina Reader extracts full article text for deeper analysis Claude Haiku scores each article 1-10 for importance, assigns categories, and writes a "why it matters" summary Claude Sonnet compiles the top articles into a structured digest with lead story, top stories, quick hits, and trend detection Formatted output is delivered to Discord (rich embeds) and Slack (Block Kit) How to use Add your Anthropic API key as an n8n credential and set your Discord webhook URL in the config node -- that's the minimum to get running Edit the feed list in "Build feed source list" to add your own sources Requirements Anthropic API key (setup guide) Discord webhook URL (setup guide) and/or Slack credential Customizing this workflow Swap feed sources for any topic -- finance, gaming, research papers, industry news Adjust topic importance weights to prioritize what you care about Modify the Claude system prompt to change the digest's tone and style