Workflow Templates

This workflow automatically launches AI-powered personalized promotional campaigns to WhatsApp users. It handles audience segmentation, message personalization, delivery via WhatsApp Business API, and tracks performance in Google Sheets. Who’s it for • Digital marketers and growth teams running high-volume WhatsApp campaigns • E-commerce businesses with opt-in customer lists • SaaS companies promoting features/upgrades • Businesses using WhatsApp for marketing and sales How it works / What it does Triggers on campaign launch (webhook/schedule) Loads audience data and performs AI-powered segmentation Generates highly personalized messages based on user behavior/demographics Sends messages via WhatsApp Business API Tracks delivery, engagement, and conversions Logs all data and metrics in Google Sheets How to set up Import this workflow Set up credentials (WhatsApp Business API, Google Sheets, OpenAI) Configure audience source and campaign templates Update AI prompt and segmentation logic Activate workflow Requirements • WhatsApp Business Account & API access (Meta) • Google Sheets for audience & tracking • OpenAI / Anthropic / Grok API • Opt-in compliant user data How to customize the workflow • Modify AI tone/offers in AI node • Update Python segmentation rules • Change Google Sheet columns • Add A/B testing or more conditions

Quick Overview This workflow exposes an MCP server endpoint for Claude Desktop and provides tools to build new n8n workflows from plain-English prompts using Google Gemini, plus tools to list, inspect, activate/deactivate workflows and review executions via the n8n Public API. How it works Receives MCP tool requests on the MCP Server Trigger endpoint (path concierge) from a connected MCP client such as Claude Desktop. Routes “build workflow” requests to a sub-workflow that sends the plain-English description to Google Gemini and asks it to return strict n8n workflow JSON (nodes and connections). Normalizes the generated JSON, adds required workflow fields, and creates the new workflow by calling the n8n Public API. Returns a compact result containing the created workflow ID and a link, leaving the workflow inactive for review. Routes “operate” requests (list/get workflows, activate/deactivate, list/get executions) to a shared sub-workflow that maps each action to the correct n8n Public API endpoint. Calls the n8n Public API with an API-key header and returns a trimmed JSON response for lists and execution data. Setup Import the MCP server workflow plus the two tool sub-workflows (Concierge Build Workflow and Concierge n8n Operate) and re-link each Tool Workflow node to the correct imported workflow ID. Create an n8n API key and configure an HTTP Header Auth credential that sends it as X-N8N-API-KEY for the HTTP Request nodes. Replace the https://YOUR_N8N_DOMAIN placeholders in the sub-workflows with your n8n instance base URL (with the Public API enabled). Add Google Gemini API credentials for the node that generates workflow JSON. Activate only the MCP server workflow to expose the Production URL, then configure Claude Desktop (for example via mcp-remote) to call that URL. For production use, switch the MCP trigger authentication to Bearer Auth and set the same token in your MCP client configuration.

Quick Overview This workflow indexes text files from Google Drive into a Supabase vector store using OpenAI embeddings, then answers Placetel webhook questions with a Groq-hosted Llama model using retrieval-augmented generation. How it works Runs a daily schedule at 02:00 or starts manually to reindex documents. Lists files in a specified Google Drive folder and iterates through each file. Downloads each file, loads its text content, generates embeddings with OpenAI, and stores the resulting chunks in a Supabase vector table. Receives a POST request from Placetel with a question in body.chatInput. Embeds the question with OpenAI, retrieves the top 3 matching chunks from the Supabase vector store, and composes an answer with Groq (Llama 3.1 8B). Returns the generated answer to the webhook caller for use in voice output. Setup Add Google Drive OAuth2 credentials and replace DEINE_ORDNER_ID in the Drive query with the folder ID you want to index. Set up Supabase (project, database, and documents table) and add Supabase credentials, ensuring the match_documents query/function is available. Add an OpenAI API key for both embedding steps and keep the same embedding model/settings for indexing and querying. Add a Groq API key and confirm the selected chat model (e.g., llama-3.1-8b-instant) is available in your Groq account. Copy the Placetel webhook URL (/rag-knowledge-webhook) and configure the calling system to send POST { "chatInput": "..." }.

Quick Overview This workflow indexes text files from Microsoft OneDrive into a Supabase vector store using OpenAI embeddings, then answers incoming webhook questions with a Groq LLM using retrieval-augmented generation (RAG) and returns the response to the caller. How it works Runs on a daily schedule at 02:00 or starts manually to re-index documents. Lists files in a specified OneDrive folder via the Microsoft Graph API and iterates through each file. Downloads each OneDrive file, loads its text content, generates OpenAI embeddings, and stores the resulting chunks in a Supabase vector store table. Receives a POST request on a webhook containing a question in body.chatInput. Creates an embedding for the question, retrieves the top matching chunks from Supabase, and uses Groq (Llama 3.1) to generate a structured answer based on the retrieved context. Returns the generated answer as the webhook response. Setup Create a Microsoft OneDrive OAuth2 credential and update the Microsoft Graph folder path in the OneDrive listing request URL. Add an OpenAI API key for embeddings and ensure the same embeddings model is used for both indexing and querying. Set up Supabase credentials and a documents table (with the configured match_documents query/function) for the Supabase vector store. Add a Groq API key and confirm the Groq model selection and prompt content match your voice-assistant use case. Copy the webhook URL and configure the calling system to send POST requests with a JSON body like { "chatInput": "..." }.

What this does Receives a URL via webhook, uses Firecrawl to scrape the page into clean markdown, and stores it as vector embeddings in Pinecone. A visual, self-hosted ingestion pipeline for RAG knowledge bases. Adding a new source is as simple as sending a URL. The second part of the workflow exposes a chat interface where an AI Agent queries the stored knowledge base to answer questions, with Cohere reranking for better retrieval quality. How it works Part 1: Ingestion Pipeline Webhook receives a POST request with a url field Verify URL validates and normalizes the domain, returning a 422 error if invalid Firecrawl /scrape fetches the page and converts it to clean markdown Embeddings OpenAI generates 1536-dimensional vector embeddings from the scraped content Default Data Loader attaches the source URL as metadata Pinecone Vector Store inserts the content and embeddings into the index Respond to Webhook confirms how many items were added Part 2: RAG Chat Agent Chat trigger receives a user question AI Agent (OpenRouter / Claude Sonnet) queries the Pinecone vector store Cohere Reranker improves retrieval quality before the agent responds Agent answers based solely on the ingested knowledge base 🔥 Firecrawl 🌲 Pinecone 🧠 OpenAI Embeddings 🤖 OpenRouter (Claude Sonnet) 🎯 Cohere Reranker Webhook usage Send a POST request to the webhook URL: curl -X POST https://your-n8n-instance/webhook/your-id \ -H "Content-Type: application/json" \ -d '{"url": "firecrawl.dev"}' Pinecone setup Your Pinecone index must be configured with 1536 dimensions to match the OpenAI text-embedding-3-small model output. See the sticky note inside the workflow for the exact index settings. Requirements Firecrawl API key OpenAI API key (for embeddings) OpenRouter API key (for the chat agent) Cohere API key (for reranking) Pinecone account with a properly configured index

Quick Overview This workflow ingests educational PDF URLs from Google Sheets, extracts and chunks their text, generates embeddings with Google Gemini, and stores them in a Supabase pgvector table for retrieval, while also exposing a public chat webhook that answers questions using Gemini and the same Supabase knowledge base. How it works Runs every hour on a schedule and reads rows from a Google Sheets document, keeping only entries where the status is empty. Processes each queued URL one at a time and routes it based on whether it is a seraj-uae.com page or a direct Google Drive file link. For seraj-uae.com URLs, fetches the HTML page to extract the PDF download link (or embedded Google Drive file ID) and the document title. Downloads the PDF from either the source website via HTTP or from Google Drive, waits briefly, and extracts text from the PDF binary. Cleans and validates the extracted text, then splits it into overlapping chunks and generates embeddings using Google Gemini. Inserts the embedded chunks into a Supabase pgvector table with file/title/source metadata and updates the Google Sheets row to “Embedded” or “Not Text Based PDF” if no text is found. Separately, exposes a public n8n Chat webhook that receives student questions and uses Gemini Flash with Supabase vector retrieval to return answers. Setup Create a Supabase project with pgvector enabled, create the seraj_documents table, and add the match_seraj_documents function used for vector search. Add Supabase API credentials in n8n and ensure the table name (seraj_documents) and query function name (match_seraj_documents) match your Supabase setup. Add Google Sheets OAuth2 credentials and update the Google Sheet document ID/sheet reference, ensuring columns include source_url, status, and row_number. Add Google Drive OAuth2 credentials for downloading PDFs hosted in Drive. Add a Google Gemini (PaLM) API credential for embeddings and Gemini Flash, then activate the workflow and copy the public chat webhook URL for your website chat widget.

🐟 Phishing URL Reputation Checker with VirusTotal This n8n template helps you automatically analyze URLs for phishing and malicious activity using VirusTotal’s multi-engine threat intelligence platform. It validates incoming URLs, submits them for scanning, polls for results, classifies risk, and logs verdicts for monitoring and incident response workflows. Use cases include security automation, SOC alerting, phishing triage pipelines, chatbot URL validation, and email security enrichment. This template is ideal for blue teams, security engineers, and automation builders who want real-time URL reputation checks without building a full security pipeline from scratch. 💡 Good to know VirusTotal enforces API rate limits. For high-volume environments, consider increasing polling intervals or rotating API keys. The workflow defangs suspicious and malicious URLs to prevent accidental clicks during investigation. This template uses asynchronous polling because VirusTotal scans are not always immediately available. ⚙️ How it works A webhook receives a URL from an API, form, chatbot, or automation trigger. The URL is normalized and validated to ensure proper formatting. Valid URLs are submitted to VirusTotal for reputation scanning. The workflow polls VirusTotal until the analysis is completed or retries are exhausted. Detection statistics are extracted and evaluated using threshold-based phishing logic. URLs classified as suspicious or phishing are defanged for safe handling. Results are returned and optionally logged to Google Sheets for auditing and tracking. 🧑‍💻 How to use Trigger the workflow using the webhook and send JSON like: { "url": "example.com" } Replace the webhook with other triggers such as email ingestion, Slack bots, or security tooling. Review the phishing verdict and risk level in the webhook response or Google Sheets log. 📋 Requirements VirusTotal API key (configured using HTTP Header Auth credentials) Google Sheets account for logging scan results 🧩 Customizing this workflow Send Slack, Microsoft Teams, or email alerts when the verdict is not SAFE. Extend the workflow with additional threat intelligence sources for stronger detection. Store scan results in databases like Airtable, PostgreSQL, or MySQL instead of Google Sheets for scalable logging and analytics.

Who's it for This template is for developers, teams, and automation enthusiasts who want a private, PIN-protected Telegram chatbot that answers questions from their own documents — without relying on external AI APIs. Ideal for internal knowledge bases, private document search, or anyone running a local LLM stack with Ollama. How it works / What it does The workflow has two flows running in parallel: Document Ingestion: Monitors a Google Drive folder for new files. When a file is added, it is downloaded, split into 500-character chunks (with 50-character overlap), embedded using Ollama's nomic-embed-text model, and stored in a PostgreSQL database with pgvector. Telegram Bot: Accepts messages from users. New users are registered and prompted for a PIN code. Once verified, users can ask any question in plain text. The question is embedded, the top 5 most similar document chunks are retrieved via cosine similarity, and qwen2.5:7b generates a context-aware answer which is sent back to the user. All queries are logged. How to set up Enable the pgvector extension in PostgreSQL and create the 4 required tables — full SQL is included in the workflow's sticky notes Install Ollama and pull the required models: ollama pull nomic-embed-text and ollama pull qwen2.5:7b Add your credentials in n8n: Telegram Bot token (from @BotFather), PostgreSQL connection, and Google Drive OAuth2 Open the Google Drive Trigger node and select the folder you want to monitor In the Register New User node, replace YOUR_PIN_CODE with your chosen access PIN Activate the workflow and send a message to your Telegram bot Requirements Ollama running locally (accessible at http://host.docker.internal:11434 if using Docker) PostgreSQL with pgvector extension (Supabase free tier works) Telegram Bot token from @BotFather Google Drive account How to customize the workflow Change the LLM model: Replace qwen2.5:7b in the Build Prompt node with any Ollama-supported model Change the embedding model: Replace nomic-embed-text in Embed Query and Embed Chunk nodes (update vector dimension in the DB schema accordingly) Adjust chunk size: Modify chunkSize and overlap values in the Split Into Chunks node Change top-K results: Edit the .slice(0, 5) in Build Prompt to return more or fewer context chunks Customize the system prompt: Edit the system message in Build Prompt to change the bot's persona or restrict its scope.

Quick overview This workflow monitors a Google Drive folder for new Tactiq transcript files, uses OpenAI to extract explicit action items, creates matching Google Tasks, sends a Telegram notification, and logs each processed transcript in an n8n Data Table to prevent duplicate processing. How it works Triggers when a new file is created in a specified Google Drive folder (or on an optional 12-hour schedule). Loads previously processed transcript filenames from an n8n Data Table and lists files in the target Google Drive folder. Filters out files that have already been processed, then downloads each new transcript and converts it to plain text. Sends the transcript text to OpenAI to return strict JSON containing only explicit action items with an owner, optional due date, and an evidence quote. Creates a Google Task for each extracted action item, including source transcript details in the task notes, and sends a Telegram error message if task creation fails. Records the transcript as processed in the n8n Data Table (including zero-task transcripts) and sends a Telegram success message. Setup Add credentials for Google Drive, Google Tasks, OpenAI, and Telegram. Create or choose an n8n Data Table to store processed transcripts (for example, with columns like nombre_archivo, fecha_proceso, and total_tareas). Update the template variables with your Google Drive folder ID, Google Tasks list ID, Data Table ID, Telegram chat ID, and preferred timezone. In the Google Drive trigger, select the same transcript folder you set in the template variables. Requirements Tactiq account, Google account

Overview This workflow automates CSV data processing from upload to database insertion. It accepts CSV files via webhook, uses AI to detect schema and standardize columns, cleans and validates the data, and stores it in Postgres. Errors are logged separately, and notifications are sent for visibility. How It Works CSV Upload A webhook receives CSV files for processing. Validation The workflow checks if the uploaded file is a valid CSV format. Invalid files are rejected with an error report. Data Extraction The CSV is parsed into structured rows for further processing. Schema Detection AI analyzes the data to: Infer column types Normalize column names Detect inconsistencies Data Normalization Values are cleaned and converted into proper formats (numbers, dates, booleans), with optional unit standardization. Data Quality Validation The workflow checks: Type mismatches Missing values Statistical outliers Conditional Processing Clean data → prepared and inserted into Postgres Errors → detailed report generated Database Insert Valid data is stored in the configured Postgres table. Error Logging Errors are logged into Google Sheets for tracking and debugging. Notifications A Slack message is sent with processing results. Setup Instructions Configure the webhook endpoint for CSV uploads Set your Postgres table name in the configuration node Add Anthropic/OpenAI credentials for schema detection Connect Slack for notifications Connect Google Sheets for error logging Configure error threshold settings Test with sample CSV files Activate the workflow Use Cases Cleaning and standardizing messy CSV data Automating ETL pipelines Preparing data for analytics or dashboards Validating incoming data before database storage Monitoring data quality with error reporting Requirements n8n instance with webhook access Postgres database OpenAI or Anthropic API access Slack workspace Google Sheets account Notes You can customize schema rules and normalization logic in the Code node. Adjust error thresholds based on your data tolerance. Extend validation rules for domain-specific requirements. Replace Postgres or Sheets with other storage systems if needed.

Who's it for Open-source maintainers, product teams with public repositories, and any organization receiving a steady stream of GitHub Issues. Ideal for small teams who waste hours per week triaging duplicates and misrouted reports. How it works When a new Issue is opened, a GitHub webhook fires this workflow. It first filters for the "opened" action, then fetches the last 30 Issues from the repository. All Issue texts (new + past) are sent to OpenAI's embeddings API in a single batch call for efficiency. The workflow calculates cosine similarity between the new Issue and every past Issue. If the maximum similarity exceeds 0.85, the new Issue is auto-closed with a comment referencing the original. Otherwise, AI classifies it into one of four categories: bug (adds label + Slack alert to dev team), question (posts FAQ link as a comment), feature (appends to a roadmap Google Sheet), or spam (auto-close with label). AI is used only for classification — the duplicate detection uses deterministic vector math, and every action is rule-based. Set up steps Generate a GitHub Personal Access Token with repo scope Create a webhook on your repository pointing to this workflow's URL, subscribing to Issues events Create a Google Sheet named feature_roadmap with columns: date_added, issue_number, title, author, url, status Open Set Configuration and fill in the repo owner, repo name, Sheet ID, Slack channel, and FAQ URL Register GitHub and OpenAI Header Auth credentials and connect Google Sheets and Slack Activate the workflow How to customize Adjust duplicate_threshold for stricter or looser matching, change the embeddings model, or swap Sheets for Notion or Airtable.

What this does Receives a URL via webhook, uses Firecrawl to scrape the page into clean markdown, and stores it as vector embeddings in Supabase pgvector. A visual, self-hosted ingestion pipeline for RAG knowledge bases. Adding a new source is as simple as sending a URL. The second part of the workflow exposes a chat interface where an AI Agent queries the stored knowledge base to answer questions, with Cohere reranking for better retrieval quality. How it works Part 1: Ingestion Pipeline Webhook receives a POST request with a url field Verify URL validates and normalizes the domain Supabase checks if the URL was already ingested (deduplication) If the URL already exists, ingestion is skipped; otherwise it continues Firecrawl fetches the page and converts it to clean markdown OpenAI generates vector embeddings from the scraped content Default Data Loader attaches the source URL as metadata Supabase Vector Store inserts the content and embeddings into pgvector Respond to Webhook confirms how many items were added Part 2: RAG Chat Agent Chat trigger receives a user question AI Agent (OpenRouter) queries the Supabase vector store filtered by URL Cohere Reranker improves retrieval quality before the agent responds Agent answers based solely on the ingested knowledge base Requirements Firecrawl API key OpenAI API key (for embeddings) OpenRouter API key (for the chat agent) Cohere API key (for reranking) Supabase project with pgvector enabled Setup Create a Supabase project and run the following SQL in the SQL editor: -- Enable the pgvector extension create extension vector with schema extensions; -- Create a table to store documents create table documents ( id bigserial primary key, content text, metadata jsonb, embedding extensions.vector(1536) ); -- Create a function to search for documents create function match_documents ( query_embedding extensions.vector(1536), match_count int default null, filter jsonb default '{}' ) returns table ( id bigint, content text, metadata jsonb, similarity float ) language plpgsql as $$ #variable_conflict use_column begin return query select id, content, metadata, 1 - (documents.embedding <=> query_embedding) as similarity from documents where metadata @> filter order by documents.embedding <=> query_embedding limit match_count; end; $$; Add your Firecrawl API key as a credential in n8n Add your OpenAI API key as a credential (for embeddings) Add your OpenRouter API key as a credential (for the chat agent) Add your Cohere API key as a credential (for reranking) Activate the workflow How to use Send a POST request to the webhook URL: curl -X POST https://your-n8n-instance/webhook/your-id \ -H "Content-Type: application/json" \ -d '{"url": "https://firecrawl.dev/docs"}' Then open the chat interface in n8n to ask questions about the ingested content.