by Yaron Been
Digitalhera Heranathalie AI Generator Description None Overview This n8n workflow integrates with the Replicate API to use the digitalhera/heranathalie model. This powerful AI model can generate high-quality other content based on your inputs. Features Easy integration with Replicate API Automated status checking and result retrieval Support for all model parameters Error handling and retry logic Clean output formatting Parameters Required Parameters prompt** (string): Prompt for generated image. If you include the trigger_word used in the training process you are more likely to activate the trained object, style, or concept in the resulting image. Optional Parameters mask** (string, default: None): Image mask for image inpainting mode. If provided, aspect_ratio, width, and height inputs are ignored. seed** (integer, default: None): Random seed. Set for reproducible generation image** (string, default: None): Input image for image to image or inpainting mode. If provided, aspect_ratio, width, and height inputs are ignored. model** (string, default: dev): Which model to run inference with. The dev model performs best with around 28 inference steps but the schnell model only needs 4 steps. width** (integer, default: None): Width of generated image. Only works if aspect_ratio is set to custom. Will be rounded to nearest multiple of 16. Incompatible with fast generation height** (integer, default: None): Height of generated image. Only works if aspect_ratio is set to custom. Will be rounded to nearest multiple of 16. Incompatible with fast generation go_fast** (boolean, default: False): Run faster predictions with model optimized for speed (currently fp8 quantized); disable to run in original bf16 extra_lora** (string, default: None): Load LoRA weights. Supports Replicate models in the format <owner>/<username> or <owner>/<username>/<version>, HuggingFace URLs in the format huggingface.co/<owner>/<model-name>, CivitAI URLs in the format civitai.com/models/<id>[/<model-name>], or arbitrary .safetensors URLs from the Internet. For example, 'fofr/flux-pixar-cars' lora_scale** (number, default: 1): Determines how strongly the main LoRA should be applied. Sane results between 0 and 1 for base inference. For go_fast we apply a 1.5x multiplier to this value; we've generally seen good performance when scaling the base value by that amount. You may still need to experiment to find the best value for your particular lora. megapixels** (string, default: 1): Approximate number of megapixels for generated image How to Use Set up your Replicate API key in the workflow Configure the required parameters for your use case Run the workflow to generate other content Access the generated output from the final node API Reference Model: digitalhera/heranathalie API Endpoint: https://api.replicate.com/v1/predictions Requirements Replicate API key n8n instance Basic understanding of other generation parameters
by Yaron Been
Ligua033 Lorealcantara AI Generator Description None Overview This n8n workflow integrates with the Replicate API to use the ligua033/lorealcantara model. This powerful AI model can generate high-quality other content based on your inputs. Features Easy integration with Replicate API Automated status checking and result retrieval Support for all model parameters Error handling and retry logic Clean output formatting Parameters Required Parameters prompt** (string): Prompt for generated image. If you include the trigger_word used in the training process you are more likely to activate the trained object, style, or concept in the resulting image. Optional Parameters mask** (string, default: None): Image mask for image inpainting mode. If provided, aspect_ratio, width, and height inputs are ignored. seed** (integer, default: None): Random seed. Set for reproducible generation image** (string, default: None): Input image for image to image or inpainting mode. If provided, aspect_ratio, width, and height inputs are ignored. model** (string, default: dev): Which model to run inference with. The dev model performs best with around 28 inference steps but the schnell model only needs 4 steps. width** (integer, default: None): Width of generated image. Only works if aspect_ratio is set to custom. Will be rounded to nearest multiple of 16. Incompatible with fast generation height** (integer, default: None): Height of generated image. Only works if aspect_ratio is set to custom. Will be rounded to nearest multiple of 16. Incompatible with fast generation go_fast** (boolean, default: False): Run faster predictions with model optimized for speed (currently fp8 quantized); disable to run in original bf16 extra_lora** (string, default: None): Load LoRA weights. Supports Replicate models in the format <owner>/<username> or <owner>/<username>/<version>, HuggingFace URLs in the format huggingface.co/<owner>/<model-name>, CivitAI URLs in the format civitai.com/models/<id>[/<model-name>], or arbitrary .safetensors URLs from the Internet. For example, 'fofr/flux-pixar-cars' lora_scale** (number, default: 1): Determines how strongly the main LoRA should be applied. Sane results between 0 and 1 for base inference. For go_fast we apply a 1.5x multiplier to this value; we've generally seen good performance when scaling the base value by that amount. You may still need to experiment to find the best value for your particular lora. megapixels** (string, default: 1): Approximate number of megapixels for generated image How to Use Set up your Replicate API key in the workflow Configure the required parameters for your use case Run the workflow to generate other content Access the generated output from the final node API Reference Model: ligua033/lorealcantara API Endpoint: https://api.replicate.com/v1/predictions Requirements Replicate API key n8n instance Basic understanding of other generation parameters
by Yaron Been
Settyan Flash V2.0.0 Beta.4 AI Generator Description None Overview This n8n workflow integrates with the Replicate API to use the settyan/flash-v2.0.0-beta.4 model. This powerful AI model can generate high-quality other content based on your inputs. Features Easy integration with Replicate API Automated status checking and result retrieval Support for all model parameters Error handling and retry logic Clean output formatting Parameters Required Parameters prompt** (string): Prompt for generated image. If you include the trigger_word used in the training process you are more likely to activate the trained object, style, or concept in the resulting image. Optional Parameters mask** (string, default: None): Image mask for image inpainting mode. If provided, aspect_ratio, width, and height inputs are ignored. seed** (integer, default: None): Random seed. Set for reproducible generation image** (string, default: None): Input image for image to image or inpainting mode. If provided, aspect_ratio, width, and height inputs are ignored. model** (string, default: dev): Which model to run inference with. The dev model performs best with around 28 inference steps but the schnell model only needs 4 steps. width** (integer, default: None): Width of generated image. Only works if aspect_ratio is set to custom. Will be rounded to nearest multiple of 16. Incompatible with fast generation height** (integer, default: None): Height of generated image. Only works if aspect_ratio is set to custom. Will be rounded to nearest multiple of 16. Incompatible with fast generation go_fast** (boolean, default: False): Run faster predictions with model optimized for speed (currently fp8 quantized); disable to run in original bf16 extra_lora** (string, default: None): Load LoRA weights. Supports Replicate models in the format <owner>/<username> or <owner>/<username>/<version>, HuggingFace URLs in the format huggingface.co/<owner>/<model-name>, CivitAI URLs in the format civitai.com/models/<id>[/<model-name>], or arbitrary .safetensors URLs from the Internet. For example, 'fofr/flux-pixar-cars' lora_scale** (number, default: 1): Determines how strongly the main LoRA should be applied. Sane results between 0 and 1 for base inference. For go_fast we apply a 1.5x multiplier to this value; we've generally seen good performance when scaling the base value by that amount. You may still need to experiment to find the best value for your particular lora. megapixels** (string, default: 1): Approximate number of megapixels for generated image How to Use Set up your Replicate API key in the workflow Configure the required parameters for your use case Run the workflow to generate other content Access the generated output from the final node API Reference Model: settyan/flash-v2.0.0-beta.4 API Endpoint: https://api.replicate.com/v1/predictions Requirements Replicate API key n8n instance Basic understanding of other generation parameters
by Yaron Been
Settyan Flash V2.0.0 Beta.9 AI Generator Description None Overview This n8n workflow integrates with the Replicate API to use the settyan/flash-v2.0.0-beta.9 model. This powerful AI model can generate high-quality other content based on your inputs. Features Easy integration with Replicate API Automated status checking and result retrieval Support for all model parameters Error handling and retry logic Clean output formatting Parameters Required Parameters prompt** (string): Prompt for generated image. If you include the trigger_word used in the training process you are more likely to activate the trained object, style, or concept in the resulting image. Optional Parameters mask** (string, default: None): Image mask for image inpainting mode. If provided, aspect_ratio, width, and height inputs are ignored. seed** (integer, default: None): Random seed. Set for reproducible generation image** (string, default: None): Input image for image to image or inpainting mode. If provided, aspect_ratio, width, and height inputs are ignored. model** (string, default: dev): Which model to run inference with. The dev model performs best with around 28 inference steps but the schnell model only needs 4 steps. width** (integer, default: None): Width of generated image. Only works if aspect_ratio is set to custom. Will be rounded to nearest multiple of 16. Incompatible with fast generation height** (integer, default: None): Height of generated image. Only works if aspect_ratio is set to custom. Will be rounded to nearest multiple of 16. Incompatible with fast generation go_fast** (boolean, default: False): Run faster predictions with model optimized for speed (currently fp8 quantized); disable to run in original bf16 extra_lora** (string, default: None): Load LoRA weights. Supports Replicate models in the format <owner>/<username> or <owner>/<username>/<version>, HuggingFace URLs in the format huggingface.co/<owner>/<model-name>, CivitAI URLs in the format civitai.com/models/<id>[/<model-name>], or arbitrary .safetensors URLs from the Internet. For example, 'fofr/flux-pixar-cars' lora_scale** (number, default: 1): Determines how strongly the main LoRA should be applied. Sane results between 0 and 1 for base inference. For go_fast we apply a 1.5x multiplier to this value; we've generally seen good performance when scaling the base value by that amount. You may still need to experiment to find the best value for your particular lora. megapixels** (string, default: 1): Approximate number of megapixels for generated image How to Use Set up your Replicate API key in the workflow Configure the required parameters for your use case Run the workflow to generate other content Access the generated output from the final node API Reference Model: settyan/flash-v2.0.0-beta.9 API Endpoint: https://api.replicate.com/v1/predictions Requirements Replicate API key n8n instance Basic understanding of other generation parameters
by Yaron Been
Settyan Flash V2.0.0 Beta.1 AI Generator Description None Overview This n8n workflow integrates with the Replicate API to use the settyan/flash-v2.0.0-beta.1 model. This powerful AI model can generate high-quality other content based on your inputs. Features Easy integration with Replicate API Automated status checking and result retrieval Support for all model parameters Error handling and retry logic Clean output formatting Parameters Required Parameters prompt** (string): Prompt for generated image. If you include the trigger_word used in the training process you are more likely to activate the trained object, style, or concept in the resulting image. Optional Parameters mask** (string, default: None): Image mask for image inpainting mode. If provided, aspect_ratio, width, and height inputs are ignored. seed** (integer, default: None): Random seed. Set for reproducible generation image** (string, default: None): Input image for image to image or inpainting mode. If provided, aspect_ratio, width, and height inputs are ignored. model** (string, default: dev): Which model to run inference with. The dev model performs best with around 28 inference steps but the schnell model only needs 4 steps. width** (integer, default: None): Width of generated image. Only works if aspect_ratio is set to custom. Will be rounded to nearest multiple of 16. Incompatible with fast generation height** (integer, default: None): Height of generated image. Only works if aspect_ratio is set to custom. Will be rounded to nearest multiple of 16. Incompatible with fast generation go_fast** (boolean, default: False): Run faster predictions with model optimized for speed (currently fp8 quantized); disable to run in original bf16 extra_lora** (string, default: None): Load LoRA weights. Supports Replicate models in the format <owner>/<username> or <owner>/<username>/<version>, HuggingFace URLs in the format huggingface.co/<owner>/<model-name>, CivitAI URLs in the format civitai.com/models/<id>[/<model-name>], or arbitrary .safetensors URLs from the Internet. For example, 'fofr/flux-pixar-cars' lora_scale** (number, default: 1): Determines how strongly the main LoRA should be applied. Sane results between 0 and 1 for base inference. For go_fast we apply a 1.5x multiplier to this value; we've generally seen good performance when scaling the base value by that amount. You may still need to experiment to find the best value for your particular lora. megapixels** (string, default: 1): Approximate number of megapixels for generated image How to Use Set up your Replicate API key in the workflow Configure the required parameters for your use case Run the workflow to generate other content Access the generated output from the final node API Reference Model: settyan/flash-v2.0.0-beta.1 API Endpoint: https://api.replicate.com/v1/predictions Requirements Replicate API key n8n instance Basic understanding of other generation parameters
by Yaron Been
Settyan Flash V2.0.0 Beta.7 AI Generator Description None Overview This n8n workflow integrates with the Replicate API to use the settyan/flash-v2.0.0-beta.7 model. This powerful AI model can generate high-quality other content based on your inputs. Features Easy integration with Replicate API Automated status checking and result retrieval Support for all model parameters Error handling and retry logic Clean output formatting Parameters Required Parameters prompt** (string): Prompt for generated image. If you include the trigger_word used in the training process you are more likely to activate the trained object, style, or concept in the resulting image. Optional Parameters mask** (string, default: None): Image mask for image inpainting mode. If provided, aspect_ratio, width, and height inputs are ignored. seed** (integer, default: None): Random seed. Set for reproducible generation image** (string, default: None): Input image for image to image or inpainting mode. If provided, aspect_ratio, width, and height inputs are ignored. model** (string, default: dev): Which model to run inference with. The dev model performs best with around 28 inference steps but the schnell model only needs 4 steps. width** (integer, default: None): Width of generated image. Only works if aspect_ratio is set to custom. Will be rounded to nearest multiple of 16. Incompatible with fast generation height** (integer, default: None): Height of generated image. Only works if aspect_ratio is set to custom. Will be rounded to nearest multiple of 16. Incompatible with fast generation go_fast** (boolean, default: False): Run faster predictions with model optimized for speed (currently fp8 quantized); disable to run in original bf16 extra_lora** (string, default: None): Load LoRA weights. Supports Replicate models in the format <owner>/<username> or <owner>/<username>/<version>, HuggingFace URLs in the format huggingface.co/<owner>/<model-name>, CivitAI URLs in the format civitai.com/models/<id>[/<model-name>], or arbitrary .safetensors URLs from the Internet. For example, 'fofr/flux-pixar-cars' lora_scale** (number, default: 1): Determines how strongly the main LoRA should be applied. Sane results between 0 and 1 for base inference. For go_fast we apply a 1.5x multiplier to this value; we've generally seen good performance when scaling the base value by that amount. You may still need to experiment to find the best value for your particular lora. megapixels** (string, default: 1): Approximate number of megapixels for generated image How to Use Set up your Replicate API key in the workflow Configure the required parameters for your use case Run the workflow to generate other content Access the generated output from the final node API Reference Model: settyan/flash-v2.0.0-beta.7 API Endpoint: https://api.replicate.com/v1/predictions Requirements Replicate API key n8n instance Basic understanding of other generation parameters
by Yaron Been
Settyan Flash V2.0.0 Beta.0 AI Generator Description None Overview This n8n workflow integrates with the Replicate API to use the settyan/flash-v2.0.0-beta.0 model. This powerful AI model can generate high-quality other content based on your inputs. Features Easy integration with Replicate API Automated status checking and result retrieval Support for all model parameters Error handling and retry logic Clean output formatting Parameters Required Parameters prompt** (string): Prompt for generated image. If you include the trigger_word used in the training process you are more likely to activate the trained object, style, or concept in the resulting image. Optional Parameters mask** (string, default: None): Image mask for image inpainting mode. If provided, aspect_ratio, width, and height inputs are ignored. seed** (integer, default: None): Random seed. Set for reproducible generation image** (string, default: None): Input image for image to image or inpainting mode. If provided, aspect_ratio, width, and height inputs are ignored. model** (string, default: dev): Which model to run inference with. The dev model performs best with around 28 inference steps but the schnell model only needs 4 steps. width** (integer, default: None): Width of generated image. Only works if aspect_ratio is set to custom. Will be rounded to nearest multiple of 16. Incompatible with fast generation height** (integer, default: None): Height of generated image. Only works if aspect_ratio is set to custom. Will be rounded to nearest multiple of 16. Incompatible with fast generation go_fast** (boolean, default: False): Run faster predictions with model optimized for speed (currently fp8 quantized); disable to run in original bf16 extra_lora** (string, default: None): Load LoRA weights. Supports Replicate models in the format <owner>/<username> or <owner>/<username>/<version>, HuggingFace URLs in the format huggingface.co/<owner>/<model-name>, CivitAI URLs in the format civitai.com/models/<id>[/<model-name>], or arbitrary .safetensors URLs from the Internet. For example, 'fofr/flux-pixar-cars' lora_scale** (number, default: 1): Determines how strongly the main LoRA should be applied. Sane results between 0 and 1 for base inference. For go_fast we apply a 1.5x multiplier to this value; we've generally seen good performance when scaling the base value by that amount. You may still need to experiment to find the best value for your particular lora. megapixels** (string, default: 1): Approximate number of megapixels for generated image How to Use Set up your Replicate API key in the workflow Configure the required parameters for your use case Run the workflow to generate other content Access the generated output from the final node API Reference Model: settyan/flash-v2.0.0-beta.0 API Endpoint: https://api.replicate.com/v1/predictions Requirements Replicate API key n8n instance Basic understanding of other generation parameters
by Yaron Been
Citoreh Nazanin AI Generator Description None Overview This n8n workflow integrates with the Replicate API to use the citoreh/nazanin model. This powerful AI model can generate high-quality other content based on your inputs. Features Easy integration with Replicate API Automated status checking and result retrieval Support for all model parameters Error handling and retry logic Clean output formatting Parameters Required Parameters prompt** (string): Prompt for generated image. If you include the trigger_word used in the training process you are more likely to activate the trained object, style, or concept in the resulting image. Optional Parameters mask** (string, default: None): Image mask for image inpainting mode. If provided, aspect_ratio, width, and height inputs are ignored. seed** (integer, default: None): Random seed. Set for reproducible generation image** (string, default: None): Input image for image to image or inpainting mode. If provided, aspect_ratio, width, and height inputs are ignored. model** (string, default: dev): Which model to run inference with. The dev model performs best with around 28 inference steps but the schnell model only needs 4 steps. width** (integer, default: None): Width of generated image. Only works if aspect_ratio is set to custom. Will be rounded to nearest multiple of 16. Incompatible with fast generation height** (integer, default: None): Height of generated image. Only works if aspect_ratio is set to custom. Will be rounded to nearest multiple of 16. Incompatible with fast generation go_fast** (boolean, default: False): Run faster predictions with model optimized for speed (currently fp8 quantized); disable to run in original bf16 extra_lora** (string, default: None): Load LoRA weights. Supports Replicate models in the format <owner>/<username> or <owner>/<username>/<version>, HuggingFace URLs in the format huggingface.co/<owner>/<model-name>, CivitAI URLs in the format civitai.com/models/<id>[/<model-name>], or arbitrary .safetensors URLs from the Internet. For example, 'fofr/flux-pixar-cars' lora_scale** (number, default: 1): Determines how strongly the main LoRA should be applied. Sane results between 0 and 1 for base inference. For go_fast we apply a 1.5x multiplier to this value; we've generally seen good performance when scaling the base value by that amount. You may still need to experiment to find the best value for your particular lora. megapixels** (string, default: 1): Approximate number of megapixels for generated image How to Use Set up your Replicate API key in the workflow Configure the required parameters for your use case Run the workflow to generate other content Access the generated output from the final node API Reference Model: citoreh/nazanin API Endpoint: https://api.replicate.com/v1/predictions Requirements Replicate API key n8n instance Basic understanding of other generation parameters
by Trung Tran
🤖 Smart Interview Assistant: Tailored Questions Based on CV, JD, and Round Watch the demo video below: 📌 Who’s it for This workflow is designed for: Recruiters* and *Talent Acquisition Specialists** who want to automate candidate interview prep. Hiring Managers** conducting multiple interviews and needing personalized question sets. Technical Interviewers** who want to save time and be well-prepared with relevant questions. ⚙️ How it works / What it does The Smart Interview Assistant automates the interview preparation process in a few clicks: Accepts: Multiple resumes (PDFs) Selected job role Chosen interview round Extracts structured data from: The candidate’s CV The corresponding Job Description (JD) Uses GPT-4 to analyze: Candidate profile Role requirements Interview round context Generates: Tailored interview questions Expected answers A summarized interview prep report Sends the report directly to the hiring team via email (SMTP) 📁 Google Drive Structure 📂 Root Folder ├── 📁 jd/ # Stores all job descriptions in PDF format │ ├── Backend_Engineer.pdf │ ├── Azure_DevOps_Lead.pdf │ └── ... └── 📄 Positions (Google Sheet) # Maps Job Role ↔ JD File Link 📝 Sample Mapping Sheet: Positions Sheet Columns: Job Role Job Description File URL (pointing to PDF in jd/ folder) 🛠️ How to Set Up Step 1: Configure API Integrations ✅ Connect your OpenAI GPT-4 API Key ✅ Enable Google Cloud APIs: Google Sheets API (to read job roles) Google Drive API (to access CV and JD files) ✅ Set up SMTP credentials (for email delivery) Step 2: Prepare Google Drive & Mapping Sheet Create a root folder on Google Drive Inside the root folder: Create a folder named /jd/ and upload all job descriptions (PDFs) Create a Google Sheet named Positions with the following format: | Job Role | Job Description File URL | |-----------------------------|--------------------------------------------| | Azure DevOps Engineer | https://drive.google.com/xxx/jd1.pdf | | Full-Stack Developer (.NET) | https://drive.google.com/xxx/jd2.pdf | Step 3: Build the Application Form Use any form tool (e.g., Typeform, Tally, or custom HTML) that collects: 📎 Resume file (PDF) 🧾 Job Role (dropdown) 🔄 Interview Round (dropdown) Step 4: Resume & JD Extraction 🔍 Use Extract from PDF to parse the resume content 📄 Retrieve the JD link from the Positions sheet based on the selected Job Role 🔗 Use Download file to pull the PDF for processing Step 5: Analyze with GPT-4 Run both Resume and JD through a Profile Analyzer Agent (GPT-4 with JSON output) Merge results Add manual input or mapping for the Interview Round metadata Step 6: Generate Interview Report Use a second GPT-4 agent (e.g., HR Expert Agent) to: Generate 6–8 tailored interview questions Include expected answers and rationale Step 7: Deliver Final Report Format the content as: 📄 PDF (optional) 📨 Email body Send the report to the recruiter, hiring manager, or interviewer via SMTP ✅ Requirements 🔑 OpenAI GPT-4 API Key 📁 Google Drive (for resume and JD storage) 📊 Google Sheet (job role mapping) 📬 SMTP credentials (host, username, password) 🧰 n8n self-hosted or cloud instance with: PDF Parser Google Sheets node HTTP Download node Email node ✏️ How to Customize the Workflow | Part | Customization Options | |----------------------------|-------------------------------------------------------------| | Form UI | Modify the design, dropdown options, or input validations | | Job Description Source | Replace Google Sheet with Notion, Airtable, or database | | Interview Metadata | Add job level, region, or language preference | | AI Prompt Tuning | Adjust prompt phrasing or temperature in GPT nodes | | Report Format | Generate PDF instead of email body using PDF node | | Delivery Method | Add internal HR portal webhook or generate downloadable link |
by Dahiana
Monitor website performance with PageSpeed Insights and save to Google Sheets with alerts This n8n template automatically monitors website performance using Google's PageSpeed Insights API, compiles detailed reports, and tracks performance trends over time in Google Sheets. Use cases: Agency client monitoring, competitor analysis, performance regression detection, SEO reporting, site migration monitoring, A/B testing performance impact, and maintaining performance SLAs. Who's it for Digital agencies monitoring client websites SEO professionals tracking site performance DevOps teams maintaining performance SLAs Business owners wanting automated site monitoring How it works Automated Testing:** Scheduled audits of multiple websites using PageSpeed Insights API Core Web Vitals:** Tracks LCP, FID, CLS, and overall performance scores Historical Tracking:** Maintains performance history for trend analysis Alert System:** Sends notifications when performance drops below thresholds Detailed Reporting:** Captures specific recommendations and optimization opportunities Two Workflow Paths Scheduled Audit: Automatically tests all URLs from Google Sheet on schedule On-Demand Testing: Webhook endpoint for immediate single-URL testing How to set up Get a free PageSpeed Insights API key from Google Cloud Console Create Google Sheet with columns: URL, Site Name, Category, Alert Threshold, Last_Processed_Date and Device. Set up Google Sheets API credentials Configure notification preferences (Slack, email, etc.) Set audit schedule (daily, weekly, or custom) Define performance thresholds for alerts Requirements Google PageSpeed Insights API key (free) Google Sheets API access n8n instance (cloud or self-hosted) Optional: Slack/email for notifications Google Sheet Structure Input Sheet ("sites"): URL, Site_Name, Category, Alert_Threshold, Last_Processed_Date and Device. Results Sheet ("audit_results"): Date, URL, Site_Name, Device, Performance_Score, LCP, FID, CLS, Recommendations, Full_Report_URL API Usage (On-Demand) POST to webhook: { "url": "https://example.com", "site_name": "Example Site", "alert_threshold": 75 } How to customize Add custom performance thresholds per site Include additional metrics (accessibility, SEO, best practices) Connect to other dashboards (Data Studio, Grafana) Add competitor benchmarking Integrate with project management tools for issue tracking Set up different notification channels based on severity Sample Google Sheet Included
by Sateesh
This workflow contains community nodes that are only compatible with the self-hosted version of n8n. AI-Powered LinkedIn Publishing via Telegram Workflow Transform your LinkedIn presence with this intelligent n8n workflow that converts simple Telegram messages into professional LinkedIn posts through AI-powered content generation and approval workflows. 🎯 Who Is This For? Content Creators & Influencers** seeking to maintain consistent LinkedIn presence Marketing Professionals** managing multiple client accounts Business Owners** wanting to automate thought leadership content Social Media Managers** streamlining content workflows Entrepreneurs** maximizing content efficiency while maintaining quality 🚀 Benefits Time Efficiency**: Reduces content creation time by 80-90% Quality Consistency**: Maintains professional standards across all posts Content Diversity**: Leverages multiple sources for rich, varied content Real-Time Relevance**: Incorporates latest industry trends and news Approval Control**: Human oversight ensures brand alignment Scalability**: Handles multiple users and high-volume content creation 🔧 Core Features Smart Content Classification Multi-Input Processing**: Handles URLs, topics, direct content, or combinations Intelligent Routing**: Automatically determines whether to scrape, search, or generate directly Context Preservation**: Maintains original user intent throughout the process Advanced Content Gathering Web Scraping**: Firecrawl integration for extracting article content from URLs Real-Time Search**: Brave Search API for latest industry trends and news Content Synthesis**: Merges multiple sources into coherent, valuable insights AI-Powered Content Generation Google Gemini Integration**: Creates professional, LinkedIn-optimized posts Platform-Specific Formatting**: Mobile-friendly paragraphs, engaging hooks, strategic CTAs SEO Optimization**: Relevant hashtags and keyword integration Character Management**: Ensures posts stay within LinkedIn's 2800 character limit Interactive Approval System Telegram Preview**: Rich preview with post analytics and formatting Action Buttons**: Approve, Edit, or Reject with single-click convenience Edit Workflow**: AI-powered rewriting based on user feedback Real-Time Updates**: Instant feedback and status notifications Comprehensive Content Tracking Google Sheets Integration**: Complete audit trail of all posts and content metrics Content Analytics**: Character counts, hashtag usage, source attribution User Authorization**: Secure access control with authorized user validation Post Management**: Unique ID generation for tracking and reference 🔄 How It Works Message Reception: Secure Telegram trigger with user validation Content Classification: AI analyzes input type and extracts actionable elements Dynamic Routing: Intelligent branching based on content requirements: URL Path: Web scraping → content extraction → processing Topic Path: Web search → latest information gathering → synthesis Direct Path: Immediate processing for ready-to-post content Content Synthesis: Merges all gathered information into comprehensive context AI Generation: Creates LinkedIn-optimized post with professional formatting Interactive Approval: Telegram preview with approval workflow Publishing: Direct LinkedIn posting upon approval Content Logging: Complete tracking in Google Sheets 📈 Use Cases Daily Industry Updates: Transform news URLs into thought leadership posts Content Repurposing: Convert articles and research into LinkedIn insights Trend Commentary: Generate posts about trending topics with real-time data Educational Content: Create informative posts from technical documentation Personal Branding: Maintain consistent professional presence with minimal effort 🛠️ Technical Requirements Required Community Nodes Install these community nodes in your n8n instance: Brave Search Integration @brave/n8n-nodes-brave-search Firecrawl Web Scraping @mendable/n8n-nodes-firecrawl LangChain AI Integration @n8n/n8n-nodes-langchain APIs & Services Required Google Gemini (Content generation and classification) Firecrawl API (Web scraping) Brave Search API (Real-time search) Telegram Bot API (Interface and notifications) LinkedIn API (Content publishing) Google Sheets API (Content tracking and logging) 🔑 Setup Guide 1. Telegram Bot Setup Search for @BotFather on Telegram Send /newbot and follow prompts Copy the bot token Send /setprivacy to BotFather and set to Disable 2. Google Gemini API Visit Google AI Studio Sign in and click "Get API Key" → "Create API Key" Copy your API key Free tier: 60 requests per minute 3. Firecrawl API Visit Firecrawl.dev Sign up and go to Dashboard → API Keys Copy your API key Free tier: 500 pages/month 4. Brave Search API Visit Brave Search API Sign up and create application Copy subscription key Free tier: 1,000 queries/month 5. LinkedIn API Visit LinkedIn Developers Create app with required details Request "Share on LinkedIn" product Copy Client ID and Client Secret Add redirect URL: https://your-n8n-domain.com/rest/oauth2-credential/callback 6. Google Sheets API Visit Google Cloud Console Enable Google Sheets API Create OAuth 2.0 Client ID Copy Client ID and Client Secret 🛠️ Installation Steps Phase 1: Preparation Install required community nodes Restart n8n after installation Create Google Sheet for logging Set up Telegram Bot Phase 2: Import and Configure Import workflow JSON in n8n Configure all API credentials Test each connection Phase 3: Customization Update authorized user ID in "Authorized Telegram Users" node Configure Google Sheets document ID Test Telegram connection Phase 4: Testing Test with different input types: URL only: https://example.com/article Topic only: artificial intelligence trends Mixed: AI trends https://example.com/ai-news 🎨 Customization Options Content Personalization Modify AI prompts to match your brand voice Adjust content length and formatting preferences Customize hashtag strategies and CTA approaches Configure approval workflow steps Source Integration Add additional search engines or content sources Integrate with RSS feeds or news APIs Connect to internal knowledge bases Customize web scraping parameters 🔒 Security Features User Authorization**: Whitelist-based access control Secure Token Management**: Encrypted API key handling Data Privacy**: Secure processing of scraped content Audit Trail**: Complete logging of all user interactions 🔮 Future Expansion Possibilities This workflow serves as a foundation for: Performance Analytics Module**: LinkedIn engagement tracking Content Optimization Engine**: A/B testing and refinement Multi-Platform Publishing**: Expand to Twitter, Facebook, Instagram Advanced Scheduling**: Time-optimized posting Content Series Management**: Automated follow-ups 💡 Why Choose This Workflow This represents a complete LinkedIn content automation solution that maintains quality and personal touch while dramatically reducing time and effort. Perfect for professionals who want to maximize LinkedIn impact without sacrificing content quality or spending hours on manual creation. Ready to transform your LinkedIn presence? Install this workflow and start automating your professional content creation today!
by Oneclick AI Squad
Description AI-Powered Multi-language Customer Support In this guide, we'll walk you through setting up a comprehensive AI-driven workflow that handles customer messages in any language through WhatsApp and email channels, providing intelligent translation, summarization, and automated responses. Ready to revolutionize your customer support? Let's get started! What's the Goal? Automatically handle customer messages** from WhatsApp and email in any language Translate and validate** incoming messages with smart language detection Generate intelligent summaries** with priority classification for support teams Provide automated responses** back to customers via their preferred channel Log all interactions** to database for tracking and analytics Send notifications** to admin team for high-priority cases Deliver 24/7 multilingual customer support** without manual effort Integrate seamlessly** with WhatsApp Business API and email systems By the end, you'll have a fully automated customer support system that handles multilingual communications, prioritizes urgent cases, and maintains comprehensive interaction logs. Why Does It Matter? Manual handling of multilingual customer support can be overwhelming and inefficient. Here's why this workflow is a game-changer: Break Global Language Barriers**: Handle customer inquiries in any language effortlessly Never Miss Important Messages**: Priority detection ensures urgent cases get immediate attention Save 80% of Manual Work**: Automation handles routine inquiries and escalates complex ones 24/7 Availability**: Respond to customers anytime, enhancing satisfaction and retention Professional Customer Experience**: Consistent, well-formatted responses in the customer's language Complete Audit Trail**: Database logging provides insights and accountability Scalable Solution**: Handle growing customer base without proportional staff increase Think of it as your always-on, multilingual customer support team that never sleeps and never misses a beat. How It Works Here's the step-by-step magic behind the automation: Step 1: Multi-Channel Message Capture WhatsApp Trigger**: Captures incoming WhatsApp messages via Business API webhook Email Trigger (IMAP)**: Monitors designated customer support email for new messages Both channels feed into the same processing pipeline for consistent handling Step 2: Data Normalization & Validation Data Normalizer & Validator**: Standardizes message format regardless of source channel Extracts key information: sender details, message content, timestamp, channel source Validates data integrity and handles malformed inputs gracefully Step 3: Smart Language Translation Smart Language Translator**: Automatically detects source language and translates to English Preserves original message context and cultural nuances Stores both original and translated versions for reference Step 4: Enhanced Summary & Priority Processing Enhanced Summary & Priority Processor**: Uses AI to analyze translated content Generates concise summaries highlighting key customer concerns Priority Classification**: Automatically tags messages as: 🔴 High Priority: Urgent issues, complaints, billing problems 🟡 Medium Priority: Product inquiries, general support 🟢 Low Priority: Thank you messages, general feedback Creates structured output with priority flags for support team triage Step 5: Message Source Intelligence Check Message Source**: Determines optimal response channel and method Routes WhatsApp messages back to WhatsApp, emails back to email Maintains conversation context and threading Step 6: Automated Customer Response Customer WhatsApp Auto-Response**: Sends acknowledgment via WhatsApp Customer Email Auto-Response**: Sends professional email replies Responses include: Confirmation of message receipt Estimated response time based on priority Reference number for tracking Next steps or immediate solutions for common issues Step 7: Database Logging & Analytics Log to Database**: Stores complete interaction history including: Original message and translation Priority classification and reasoning Response sent and timestamp Customer contact information Channel and source metadata Enables analytics, reporting, and quality assurance Step 8: Admin Notifications & Alerts Admin Email Notification**: Immediate email alerts for high-priority cases Admin WhatsApp Alert**: SMS/WhatsApp notifications for urgent escalations Workflow Completion & Metrics**: Performance tracking and completion confirmations Workflow Architecture ┌─────────────────┐ ┌──────────────────┐ │ WhatsApp │ │ Email Trigger │ │ Trigger │ │ (IMAP) │ └─────────┬───────┘ └─────────┬────────┘ │ │ └──────────┬───────────┘ │ ┌──────────▼──────────┐ │ Data Normalizer & │ │ Validator │ └──────────┬──────────┘ │ ┌──────────▼──────────┐ │ Smart Language │ │ Translator │ └──────────┬──────────┘ │ ┌──────────▼──────────┐ │ Enhanced Summary & │ │ Priority Processor │ └──────────┬──────────┘ │ ┌──────────▼──────────┐ │ Check Message │ │ Source │ └─────────┬┬──────────┘ ┌┘└┐ ┌──────────▼┐ ┌▼──────────┐ │ Customer │ │ Customer │ │ WhatsApp │ │ Email │ │ Response │ │ Response │ └──────────┬┘ └┬──────────┘ └┬─┬┘ ┌─────────▼─▼─────────┐ │ Log to Database │ └─────────┬───────────┘ │ ┌─────────▼───────────┐ │ Admin Email │ │ Notification │ └─────────┬───────────┘ │ ┌─────────▼───────────┐ │ Admin WhatsApp │ │ Alert │ └─────────┬───────────┘ │ ┌─────────▼───────────┐ │ Workflow Completion │ │ & Metrics │ └─────────────────────┘ How to Use the Workflow? Importing a workflow in n8n is straightforward and allows you to use pre-built or shared workflows to save time. Below is a step-by-step guide to importing the Multi-language Customer Support workflow in n8n. Steps to Import a Workflow in n8n 1. Obtain the Workflow JSON Source the Workflow: Workflows are typically shared as JSON files or code snippets. You might receive them from: The n8n community (e.g., n8n.io workflows page) A colleague or tutorial (e.g., a .json file or copied JSON code) Exported from another n8n instance Format**: Ensure you have the workflow in JSON format, either as a file (e.g., customer-support-workflow.json) or as text copied to your clipboard 2. Access the n8n Workflow Editor Log in to n8n: Open your n8n instance (via n8n Cloud or your self-hosted instance) Navigate to the Workflows tab in the n8n dashboard Open a New Workflow: Click Add Workflow to create a blank workflow, or open an existing workflow if you want to merge the imported workflow 3. Import the Workflow Option 1: Import via JSON Code (Clipboard): In the n8n editor, click the three dots (⋯) in the top-right corner to open the menu Select Import from Clipboard Paste the JSON code of the workflow into the provided text box Click Import to load the workflow into the editor Option 2: Import via JSON File: In the n8n editor, click the three dots (⋯) in the top-right corner Select Import from File Choose the .json file from your computer Click Open to import the workflow Configuration Requirements Essential Setup Notes: WhatsApp Integration: Configure WhatsApp Business API credentials in the WhatsApp Trigger node Set up webhook URL in your WhatsApp Business account Test connection with a sample message Email Configuration: Set up IMAP credentials for your customer support email in the Email Trigger node Configure SMTP settings for outbound email responses Ensure proper email authentication (SPF, DKIM records) Translation Services: Add Google Translate API credentials in the Smart Language Translator node Alternative: Configure Azure Translator or AWS Translate based on preference Set up language detection and translation parameters Database Connection: Configure database credentials in the "Log to Database" node Create required tables for storing customer interactions: CREATE TABLE customer_interactions ( id SERIAL PRIMARY KEY, customer_contact VARCHAR(255), channel VARCHAR(50), original_message TEXT, translated_message TEXT, summary TEXT, priority VARCHAR(20), response_sent TEXT, timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); Admin Notifications: Set up admin email addresses in notification nodes Configure WhatsApp/SMS credentials for urgent alerts Customize notification templates and thresholds Priority Classification Rules: Customize JavaScript code in "Enhanced Summary & Priority Processor" node Define keywords and patterns for priority detection: // High Priority Keywords const urgentKeywords = ['urgent', 'emergency', 'billing issue', 'not working', 'broken', 'refund', 'complaint']; // Medium Priority Keywords const mediumKeywords = ['question', 'how to', 'support', 'help', 'information']; // Classification logic if (urgentKeywords.some(keyword => message.toLowerCase().includes(keyword))) { priority = 'HIGH'; } else if (mediumKeywords.some(keyword => message.toLowerCase().includes(keyword))) { priority = 'MEDIUM'; } else { priority = 'LOW'; } Response Templates: Customize auto-response templates in both WhatsApp and Email response nodes Include your company branding and contact information Set up response templates for different priority levels and common scenarios Testing and Deployment: Test Each Channel: Send test messages via WhatsApp and email to verify end-to-end flow Verify Translations: Test with messages in different languages Check Database Logging: Confirm all interactions are properly stored Test Admin Notifications: Verify alerts are sent for high-priority cases Monitor Performance: Set up workflow execution monitoring and error handling Your Multi-language Customer Support workflow is now ready to handle customer communications 24/7 across multiple channels with intelligent automation and human oversight where needed!