by Oriol Seguí
This template allows you to automatically fetch WHOIS data for any domain and display it in a clean, modern HTML card. It doesn’t just stop at showing raw registry data — it also uses a lightweight AI model to generate a short analysis or conclusion about the domain. It’s designed for SEO specialists, web developers, sysadmins, digital marketers, and cybersecurity enthusiasts who want quick and structured access to domain ownership and status details without wasting time on manual searches. What it does: Receives a domain name via webhook. Queries the WHOIS API through RapidAPI. Extracts and formats key details (registrar, creation date, expiry date, DNS, domain status, etc.). Uses AI (GPT-5-Nano) to generate a short descriptive insight about the domain. Returns everything in a responsive, styled HTML card (light + dark mode included). Requirements: A free account on RapidAPI.com. Use of the Bulk WHOIS API (includes up to 1,000 requests per month free, no credit card required). Who is it for? SEO professionals** who need to quickly check domain lifespans, expirations, and registrar info. Web developers** who want to integrate WHOIS checks into dashboards, apps, or chatbots. IT admins & security teams** who monitor domains for fraud, abuse, or expiry. Entrepreneurs & marketers** researching competitors’ domains. This template saves time, improves workflows, and makes WHOIS data both actionable and user-friendly.
by Adrian Kendall
Key Features Implements a simple round-robin distribution mechanism using a Data Table to track the last route used. Supports multiple downstream workflows or resources, balancing workload across them sequentially. Uses Switch and Code nodes for flexible routing logic. Designed for easy customization — replace placeholder “Route” nodes with sub-workflow calls or API triggers. Works with any trigger type, and includes merge logic to preserve input data. Nodes in Use | Node Name | Type | Purpose | |-------------------------------------------------|---------------|--------------------------------------------------------------------------| | When clicking ‘Execute workflow’ | Manual Trigger | Test entry point for manual execution. | | Calculate the next route to use | Data Table | Retrieves the last used route number. | | Code in JavaScript | Code | Increments the route counter (0–3 cycle). | | Update last_used in the datatable | Data Table | Updates the “Last_Used” field to track next route. | | Round Robin Router | Switch | Routes workflow execution to the correct path based on Last_Used value. | | Route 1 / Route 2 / Route 3 | NoOp | Placeholder routes — replace with your own workflows. | | Merge trigger data to pass to subworkflow if needed | Merge | Combines trigger data with routing data for sub-workflows. | | Sticky Notes | Annotations | Explain workflow logic and intended replacements. | How It Works The workflow starts when triggered manually (or by another workflow). The Data Table node fetches the current value of Last_Used, which identifies which route was last used. The Code node increments that value, resetting to 0 after 3, creating a round-robin cycle. The Data Table update node stores the new Last_Used value. The Switch node reads Last_Used and routes execution to the correct downstream branch. Each route can represent a duplicated workflow, resource, or API endpoint. Optionally, the Merge node reattaches trigger data before sending it to sub-workflows. Step-by-Step Trigger the workflow manually or via webhook/cron/etc. Retrieve current route index using the Data Table node. Increment route counter with the JavaScript Code node: If Last_Used = 3, it resets to 0. Otherwise, increments by 1. Update Data Table with the new Last_Used value. Route execution using the Switch node based on that value. Send data to corresponding subworkflow (Route 1, Route 2, Route 3). Replace the NoOp nodes with your target workflow or HTTP call nodes for real routing. Use Cases Distribute load across multiple API endpoints to prevent throttling. Run identical sub-workflows on different worker instances for parallel processing. Simulate load balancing during testing of N8N workflows. Sequentially alternate between external systems or servers handling similar tasks. Act as a proof-of-concept for balancing strategies before scaling up.
by Wayne Simpson
This template is a practical introduction to n8n Webhooks with built-in examples for all major HTTP methods and authentication types. It is designed as a learning resource to help you understand how webhooks work in n8n, how to connect them to a data store, and how to secure them properly. What’s included: Webhook nodes for GET, POST, PUT, PATCH, DELETE, and HEAD Demonstrations of Basic Auth, Header Auth, and JWT Auth Supabase integration for creating, retrieving, updating, and deleting rows Example response handling with Respond to Webhook nodes Sticky notes explaining each method, response type, and security option Use this template to: Learn how to configure and test webhooks in n8n Explore different authentication strategies Connect webhooks to a simple Supabase table Understand best practices for securing webhook endpoints This workflow is intended as an educational starting point. It shows you how to receive requests, map data, and return responses securely. For production use, adapt the structure, apply your own security policies, and extend the logic as needed. Check out the YouTube video here: https://www.youtube.com/watch?v=o6F36xsiuBk
by s3110
LINE x Google Account Linking Workflow This workflow automates the process of linking a new user on your LINE Official Account to their Google Account. When a user adds your LINE account as a friend, this workflow automatically sends them a message with a unique authentication link. After the user approves the connection, their Google profile information is fetched, and a confirmation message is sent, completing the loop. Prerequisites Before you begin, ensure you have the following: An n8n instance:** Either on n8n.cloud or a self-hosted environment. A LINE Developers Account:** A Messaging API channel. Your Channel Access Token (long-lived). A Google Cloud Platform (GCP) Account:** A configured OAuth consent screen. An OAuth 2.0 Client ID and Client Secret. Setup Instructions Follow these steps to configure the workflow. Step 1: Configure LINE Developers Console Log in to the LINE Developers Console. Navigate to your provider and select your Messaging API channel. Go to the Messaging API tab. Issue a Channel access token (long-lived) and copy the value. In the Webhook URL field, paste the Test URL from the LINE Webhook node in your n8n workflow. Enable Use webhook. Step 2: Configure Google Cloud Platform (GCP) Log in to the Google Cloud Console and select your project. Navigate to APIs & Services > OAuth consent screen. Configure it if you haven't already, ensuring you add your own Google account as a test user. Go to APIs & Services > Credentials. Click + CREATE CREDENTIALS and select OAuth 2.0 Client ID. For Application type, choose Web application. Under Authorized redirect URIs, click + ADD URI and paste the Test URL from the Google Auth Callback node in your n8n workflow. Click Create. Copy your Client ID and Client Secret. Step 3: Configure the n8n Workflow Import the workflow JSON into your n8n canvas and follow these steps to set it up. 1. Configure n8n Credentials First, set up the credentials that the HTTP Request nodes will use. For the LINE Messaging API:** In n8n, go to Credentials > Add credential. Search for and select Header Auth. Set Name to Authorization. Set Value to Bearer YOUR_LINE_CHANNEL_ACCESS_TOKEN (replace with the token from Step 1). Save the credential with a memorable name like "LINE Messaging API Auth". For the Google API (Dynamic Token):** Create another Header Auth credential. Set Name to Authorization. For Value, enter a placeholder like Bearer dummy_token. This will be replaced dynamically by the workflow. Save the credential with a name like "Google API Dynamic Token". 2. Update Node Parameters Now, update the parameters in the following nodes: Create Google Auth URL node:** In the value field, replace YOUR_N8N_WEBHOOK_URL_FOR_GOOGLE with the webhook URL of the Google Auth Callback node. Replace YOUR_GOOGLE_CLIENT_ID with the Client ID from GCP (Step 2). Get Google Access Token node:** In the jsonBody field, replace YOUR_GOOGLE_CLIENT_ID, YOUR_GOOGLE_CLIENT_SECRET, and YOUR_N8N_WEBHOOK_URL_FOR_GOOGLE with your actual GCP credentials and callback URL. Get Google User Info node:** For Authentication, select Header Auth. For Credential for Header Auth, choose the "Google API Dynamic Token" credential you created. Important: Click Add Option > Header To Append. Set the Name to Authorization and the Value to the following expression to use the token from the previous step: Bearer {{ $node["Get Google Access Token"].json["access_token"] }}. Send Auth Link to LINE & Send Completion Message to LINE nodes:** For Credential for Header Auth, choose the "LINE Messaging API Auth" credential. Redirect to LINE OA node:** In the redirectURL parameter, replace YOUR_LINE_OFFICIAL_ACCOUNT_ID with your LINE OA's ID (e.g., @123abcde). Step 4: Activate and Test Save the workflow by clicking the Save button. Activate the workflow using the toggle in the top-right corner. On your phone, add your LINE Official Account as a friend. You should receive a message with a link. Follow the link to authorize with your Google account. After successful authorization, you should receive a completion message in LINE and be redirected. > Note: When you are ready for production, remember to replace the "Test" webhook URLs in the LINE and GCP consoles with the "Production" URLs from the n8n webhook nodes.
by Cheng Siong Chin
Compare AI Models with Nvidia API: Qwen, DeepSeek, Seed-OSS & Nemotron Overview Queries four AI models simultaneously via Nvidia's API in 2-3 seconds—4x faster than sequential processing. Perfect for ensemble intelligence, model comparison, or redundancy. How It Works Webhook Trigger receives queries AI Router distributes to four parallel branches: Qwen2, SyncGenInstruct, DeepSeek-v3.1, and Nvidia Nemotron Merge Node aggregates responses (continues with partial results on timeout) Format Response structures output Webhook Response returns JSON with all model outputs Prerequisites Nvidia API key from build.nvidia.com (free tier available) n8n v1.0.0+ with HTTP access Model access in Nvidia dashboard Setup Import workflow JSON Configure HTTP nodes: Authentication → Header Auth → Authorization: Bearer YOUR_API_KEY Activate workflow and test Customization Adjust temperature/max_tokens in HTTP nodes, add/remove models by duplicating nodes, change primary response selection in Format node, or add Redis caching for frequent queries. Use Cases Multi-model chatbots, A/B testing, code review, research assistance, and production systems with AI fallback.
by Tran Trung Nghia
Cheap Nano Banana API - AI Image Generator with BananaAPI.com Overview This workflow integrates BananaAPI.com with the Nano Banana image engine to generate or edit AI images from text prompts and optional reference images. Users simply fill out a form with their prompt and preferences, the workflow submits the request to BananaAPI, polls the status until it is complete, and then returns the final image link. Why use it? Super affordable: only $0.025 per image Pay-as-you-go** pricing — no monthly subscription Credits never expire** — use anytime, no pressure Perfect for creators, marketers, and developers looking for a cost-effective AI image generator inside n8n. Prerequisites A BananaAPI.com account + API key (Bearer token). Sign up at BananaAPI.com. An n8n instance (Cloud or self-hosted). Basic knowledge of crafting AI prompts for better quality results. ⚠️ Important: Never expose your API key in public workflows. Use n8n Credentials for production setups. Setup Instructions 1. Obtain API Key Create an account at BananaAPI.com, generate your API key, and keep it safe. 2. Configure the Form The Form Trigger collects the following fields: api_token (required) — Banana API key prompt (required) — image description (e.g., “a neon cyberpunk cat, detailed, 4k”) Output Format [optional] — choose PNG or JPEG Image Size [optional] — 16:9, 9:16, 1:1, 3:4, 4:3 image_url_1 ... image_url_5 [optional] — reference images for editing/transform 3. Workflow Execution User fills the form and submits. Workflow sends a POST request to https://bananaapi.com/api/n8n/generate/. BananaAPI forwards the job to Nano Banana. Workflow waits 5s, then polls status via image-status/{taskId}. If status != completed, loop until ready. Once completed, workflow returns the final image URL. 4. Outputs The workflow returns: image_url — the generated image link task_id — task reference ID status — job status (completed/pending) 💡 Tip: Add a Webhook Response node to return clean JSON for frontend apps. Customization Tips Enhance prompts** with details like style (photorealistic, cartoon, cyberpunk), lighting, or action for better results. Use image_url_1 with a strong prompt to create image editing flows. Adjust wait time (5s → 8–10s) to optimize polling frequency. Add validation to ensure required fields are always filled in. API Reference POST** https://bananaapi.com/api/n8n/generate/ GET** https://bananaapi.com/api/n8n/image-status/{taskId} Docs: BananaAPI Docs ✅ Always include Authorization: Bearer <token> in headers. Pricing Advantages $0.025 per image** — cheaper than most alternatives Pay-as-you-go** — no monthly subscription required Credits never expire** — full flexibility to use anytime This makes BananaAPI + Nano Banana one of the most budget-friendly AI image solutions for automation workflows. Troubleshooting 401/403 Unauthorized** → Check Authorization header (Bearer token). Invalid JSON** → Ensure POST body is valid JSON (double quotes, no trailing commas). No imageUrl returned** → Task still pending; wait longer or verify taskId. Slow performance** → Increase wait interval (8–10s). Security Best Practices Do not hardcode API tokens in public workflows. Use n8n Credentials for storing tokens securely. Hide sensitive fields in forms or use Webhooks for controlled access.
by Tran Trung Nghia
Veo 3 Video Generator via VietVid.com API (n8n) Overview This workflow leverages the VietVid.com Veo3 model to generate AI videos from simple text descriptions or optional images. Users interact via a form interface, inputting a prompt (e.g., a scene description), choosing aspect ratio and model, then the system automatically submits the request to the VietVid API, monitors the generation status in real time, and retrieves the final video output. It’s ideal for content creators, marketers, and developers exploring text-to-video AI creation, supporting intelligent video generation with minimal setup. Prerequisites A VietVid.com account and API key: Register at VietVid.com to obtain your free or paid API key. An active n8n instance (cloud or self-hosted) with HTTP Request, Wait, and form submission capabilities. Basic knowledge of AI prompts for video generation to achieve optimal results. Setup Instructions 1. Obtain API Key Register at VietVid.com and generate your API key. Store it securely—do not share publicly. 2. Configure the Form In the Form Trigger node, ensure the following fields are available: text_prompt — video description (e.g., “A serene mountain landscape at sunset with birds flying”) ImageURL [optional] — optional image input for image-to-video api_Token — your VietVid API key aspect_Ratio [16:9,9:16] — dropdown to select ratio model — choose between veo3 and veo3_fast 3. Test the Workflow Click Execute Workflow in n8n. Access the generated form URL. Submit your prompt, API key, and options. The workflow will poll the VietVid API every 10 seconds until the video is ready. 4. Handle Outputs The final Set node formats and displays the video links: 720p_link — always available when ready. 1080p_link — available only for 16:9 aspect ratio. Customization Tips Enhance prompts*: Add details like style (realistic, cinematic, animated*), duration, actions, and camera/lighting for better results. Stability**: Fix the seeds value (e.g., 50000) for more consistent characters. Webhook Response: Add a **Webhook Response node to return a clean JSON payload for frontend integrations. Adjust polling delay**: Modify Wait node (8–15s) if needed to balance speed vs. API calls.
by Anderson Adelino
Who's it for This template is perfect for community managers, business owners, and WhatsApp group administrators who want to create a welcoming experience for new members. Whether you're running a support group, managing a business community, or moderating a hobby group, this automation ensures every new member feels valued from the moment they join. How it works The workflow automatically detects when someone joins your WhatsApp group and sends them a personalized welcome message directly to their private chat. It uses Evolution API to interface with WhatsApp Business and includes a natural delay to make the interaction feel more human. The entire process is hands-off once configured, ensuring consistent engagement with new members 24/7. What it does Monitors group activity - Receives real-time notifications when members join or leave Filters for your specific group - Ensures messages are only sent for your designated group Validates new joins - Confirms the event is a member joining (not leaving) Adds natural timing - Waits a customizable period before sending the message Sends private welcome - Delivers your welcome message directly to the new member's chat Requirements Evolution API instance** (self-hosted or cloud service) WhatsApp Business account** connected to Evolution API Group admin permissions** for the WhatsApp group n8n instance** (self-hosted or cloud) How to set up Import the workflow into your n8n instance Configure the Set Variables node with: Your WhatsApp group ID (format: xxxxxxxxxxxxx@g.us) Evolution API key Instance name from Evolution API Evolution API URL Custom welcome message Delay time in minutes Copy the webhook URL from the Webhook node Configure Evolution API to send group notifications to your webhook URL Test the workflow by having someone join your group Activate the workflow for continuous operation For a detailed video tutorial on setting up this workflow, check out: https://youtu.be/WO2MJoQqLvo How to customize the workflow Welcome message**: Edit the message in the Set Variables node to match your group's tone Timing**: Adjust the wait time to send messages immediately or after several minutes Multiple groups**: Duplicate the workflow and change the group ID for each group Rich media**: Extend the HTTP Request node to send images or documents with the welcome Conditional messages**: Add IF nodes to send different messages based on time of day or member count Follow-up sequence**: Chain additional HTTP Request nodes to create a welcome series
by System Admin
Tagged with: , , , ,
by Ruslan Elishev
🤖 Telegram Bot with Dynamic Multi-Level Menu System What This Workflow Does Ever wanted to build a Telegram bot with professional-looking menus that actually work? This n8n workflow creates an interactive bot with dynamic inline keyboards, multi-level navigation, and smart button routing - all without writing complex code from scratch. The bot features a clean separation between your menu structure and business logic. This means you can change your menus anytime without breaking the underlying functionality. Think of it like WordPress menus but for Telegram bots - you define the navigation, and the workflow handles everything else. Your bot will respond with personalized messages, remember user context, handle button clicks smoothly (no annoying loading spinners!), and route different actions to specialized handlers. Whether users are rating your service, checking their subscription status, or navigating through settings, everything just works. 🚀 Getting Started in 3 Minutes Step 1: Get Your Bot Token Head over to Telegram and chat with @BotFather. Create a new bot (or use an existing one) and grab that token. In the workflow, find the purple "Set Bot Token" node and replace [!!! YOUR_BOT_TOKEN_HERE !!!] with your actual token. Step 2: Activate the Magic Save the workflow, click on "Production" tab, and you'll see a webhook URL. Toggle the workflow to Active. That's it - your bot is live! Step 3: See It In Action Message your bot on Telegram. Type /start and watch your beautiful menu appear. Click around, explore the buttons - everything is already set up and working. 🎨 Making It Yours Want to Add Your Own Menus? Open the workflow and look for the sticky note titled "📖 COMPLETE GUIDE: ADDING MENUS & ACTIONS". I've written step-by-step instructions right there in the workflow. You'll find exact examples showing how to add a contact menu, subscription status checker, or whatever you need. The beauty is in the simplicity - menus are just text and buttons. No complicated logic mixed in. Check the "📚 REAL EXAMPLES" sticky note for copy-paste templates you can modify. Need Custom Actions? When a button needs to actually DO something (save data, call an API, send an email), that's where handlers come in. The workflow includes 7 pre-built handlers for common tasks like ratings, language switching, and analytics. Want to add your own? The "💡 ADDING HANDLERS" sticky note walks you through it. 💡 Why This Workflow Is Different Most Telegram bot tutorials have you mixing menu code with business logic, making changes a nightmare. This workflow separates everything cleanly. Your menus live in one place, your logic in another. It's like having a control panel for your bot. The workflow also solves a common n8n limitation - the native Telegram node doesn't support dynamic inline keyboards. Instead of giving up, this workflow uses HTTP requests directly to the Telegram API, giving you full control over every feature. 🔧 Pro Tips from the Trenches After building dozens of Telegram bots, here's what I've learned: Always include a "Back" button - users panic without an escape route Use emojis in your buttons - they make everything friendlier Test each menu path after changes - one typo can break navigation Keep action handlers focused - one handler, one job Hit a snag? Check the "🐛 TROUBLESHOOTING & TIPS" sticky note in the workflow. I've documented all the common "gotchas" and their fixes. 📦 What's Included This workflow comes with everything you need: Centralized menu configuration system Smart routing that automatically detects which button was pressed 7 ready-to-use action handlers (modify or replace as needed) Parallel processing for lightning-fast responses Built-in error handling with fallback menus Comprehensive documentation right in the workflow via sticky notes 🚀 Taking It Further Once you're comfortable with the basics, this architecture scales beautifully. Connect a database to remember user preferences. Integrate with your CRM to pull customer data. Add payment processing for a shopping bot. The modular design means you can enhance one part without touching the others. The workflow sticky notes contain advanced examples for multi-language support, user authentication, and API integrations. Everything is explained in plain English with code examples you can actually use. 🤝 One Last Thing This workflow started as a simple dynamic menu with rating workflow and evolved into something much more powerful through community feedback. If you build something cool with it, I'd love to hear about it. And if you get stuck, remember - all the answers are in those sticky notes. I spent way too much time making them ridiculously detailed so you wouldn't have to struggle like I did. Happy bot building! 🎯 Version: 1.0 - Centralized Menu System with Branching Author: Ruslan Elishev
by System Admin
Tagged with: , , , ,
by System Admin
Tagged with: , , , ,