n8n 8 Hour Masterclass: Build & Sell AI Agents (Automate Anything)

Here's a comprehensive summary of the provided YouTube video transcript, maintaining the original language and technical precision:

Key Concepts:

• N8N: An automation platform that connects applications.
• Workflows: Automated sequences of tasks.
• Triggers: Events that initiate a workflow.
• Actions: Tasks performed within a workflow.
• Nodes: Individual steps or components within a workflow.
• Mapping: The process of transferring data between nodes.
• Data Types: String, Number, Boolean, Binary, Array, Object.
• Functions: Built-in capabilities to manipulate data within fields.
• Filters: Logic to remove items that don't meet specific criteria.
• If/Else Statements: Conditional logic to route workflows down different paths.
• Switch Statements: Multi-path conditional logic based on a value.
• Merge Nodes: Combining data from multiple workflow paths.
• Polling Triggers: Triggers that check for updates at intervals.
• Instant Triggers: Triggers that activate immediately upon an event.
• API Keys: Credentials for accessing third-party services.
• Web Scraping: Extracting data from websites.
• AI Agents: Autonomous workflows that can reason and use tools.
• System Prompts: Instructions for AI agents.
• Tools: Capabilities an AI agent can access (e.g., Gmail, Google Calendar).
• Memory: AI agent's ability to recall past interactions.
• Vector Stores: Databases that store and retrieve information based on semantic meaning.
• Embeddings: Numerical representations of text for AI processing.
• RAG (Retrieval Augmented Generation): AI systems that retrieve information from a knowledge base before generating a response.
• Webhooks: A mechanism for real-time data transfer between applications.
• HTTP Methods: POST, PUT, GET, DELETE for data transfer.
• Rate Limiting: Restrictions on the number of requests to an API.
• Error Handling: Strategies for managing and resolving workflow errors.
• Self-Hosting: Running N8N on your own infrastructure.

---

Summary of N8N Masterclass

This comprehensive masterclass provides an in-depth guide to mastering the N8N automation platform, aiming to transform users into experts capable of building complex workflows and AI agents. The course emphasizes practical application, promising to equip learners with the skills to save time and potentially generate revenue through automation.

1. Introduction to N8N and Its Capabilities

• Definition: N8N is an automation platform that connects various applications, enabling them to communicate and automate tasks.
• Core Functionality: It automates workflows by connecting different apps, allowing data to flow between them.
• Use Cases:
  • Gmail Automation: Categorizing emails using AI, automatically deleting unwanted emails (e.g., promotions, social notifications), and drafting AI-powered responses.
  • Google Docs Automation: Automatically generating styled Google Docs with titles, colored text, and images, with the ability to upload custom styling guides.
  • AI Blog Generation: Creating SEO-optimized blog content with AI-generated styling and images, which the presenter claims led to 1,500 daily Google clicks and significant revenue.
  • Google Drive Organization: Automating the cleanup and organization of Google Drive files into correct folders.
  • AI Agents for Data Extraction: Building AI agents that can process messages from platforms like Telegram (e.g., receipts, invoices) to extract specific data points (line items) and input them into Google Sheets.
• Opportunities:
  • Business Automation: Automating up to 80% of tasks in a business, enabling scaling to seven figures.
  • Service Business: Offering automation services to business owners who lack the expertise to implement these solutions.
  • Career Advancement: Enhancing efficiency at a current job, leading to promotions, raises, or new opportunities in the AI automation space.
• Presenter's Credibility: Jonno, the presenter, has a YouTube channel with over 100,000 subscribers, a community of 500 members, and has built two seven-figure businesses, one in AI automation.

2. N8N Fundamentals and Workflow Building

• Learning Goal: To teach users "how to fish," providing foundational knowledge for independent problem-solving.
• Practical Approach: Building 10 distinct workflows, starting with basic automation and progressing to AI agents.
• Cost: $0 for the learning process, with no coding skills required.
• Account Setup:
  • Creating a free N8N account, using an incognito window to mimic a new user experience.
  • Navigating the pricing page, noting the 14-day free trial without requiring credit card details.
  • The concept of "self-hosting" is introduced as a way to bypass limitations and potentially reduce costs, to be covered later.
  • Basic account creation involves email, password, and account name.
  • Skipping optional steps like adding co-workers for personal use.
• Workspace Navigation:
  • Focus on the "Personal" folder and "Projects" for collaborative workflows.
  • Settings for managing users and project members.
  • Emphasis on practical usage, avoiding less frequently used features.
• Build with AI Feature:
  • Allows workflow creation via natural language prompts (similar to ChatGPT).
  • Example: "Create a workflow that fetches the latest AI news every morning at 8 a.m."
  • Acknowledged as a helpful accelerator but not a replacement for understanding core fundamentals, as it may only complete 50-70% of a workflow.

3. Workflow 1: New Lead System

• Objective: Automate the process of capturing and responding to new leads from a website form.
• Impact: Calling leads within 60 seconds of inquiry can increase conversion rates fourfold.
• Workflow Steps:
  1. Trigger: Form Submission:
     • N8N allows building forms within the platform.
     • Form Configuration:
       • Form URL: Access point for the form.
       • Authentication: Set to "none" for public access.
       • Form Title: "Contact Us."
       • Form Description: "Get a quote now."
       • Form Elements:
         • Full Name (Text Field, Required)
         • Email (Email Field, Required, with validation)
         • Service (Dropdown: SEO, Ads)
         • Budget (Number Field, Required)
     • Execution: Clicking "Execute Step" previews the form.
     • Data Output: Submitted data is displayed in Table, Schema, and JSON formats. JSON is highlighted as the backbone of N8N data transfer.
  2. Action: Add to Google Sheets:
     • Node Type: Action in App (Google Sheets).
     • Operation: "Append row in sheet."
     • Credential Setup: Connecting N8N to Google Sheets via OAuth.
     • Document Selection: Creating a new Google Sheet named "N8N new lead sheet" with headers: Full Name, Email, Service, Budget, Rejected, Contacted, Date.
     • Mapping: Connecting input data fields (from the form submission) to the corresponding Google Sheet columns (e.g., Full Name to Full Name). Green text indicates mapped JSON data.
     • Functions: Introduction to the today function for dynamic date insertion.
     • Testing: Executing the workflow with sample data (Jonno Catliff, Jane Smith) to verify data population in Google Sheets.
  3. Action: Filter Leads:
     • Node Type: Flow -> Filter.
     • Purpose: Remove leads that don't meet specific criteria (e.g., budget under $1,000).
     • Condition: Budget (Number) is greater than or equal to $1,000.
     • Data Type Handling: Addressing "wrong type" errors by ensuring data types match (e.g., converting budget to a number).
     • Output: "Discarded" indicates items that failed the filter.
     • Workaround for Testing: Editing pinned data to adjust budget values to pass filters for testing subsequent workflow steps.
  4. Action: Send Email Notification (to self):
     • Node Type: Action in App (Gmail).
     • Operation: "Send message."
     • Credential Setup: Connecting N8N to Gmail account.
     • Configuration:
       • To: Self (for notification).
       • Subject: "New Lead" with a bell emoji.
       • Body: Dynamic text including mapped data (Name, Email, Service, Budget).
       • Options: Disabling "Append attribution" to remove N8N branding from emails.
     • Testing: Verifying email receipt with mapped dynamic data.
  5. Action: Conditional Email (If/Else):
     • Node Type: Flow -> If.
     • Condition: Service (from form submission) equals "Ads."
     • True Path: Send a tailored email for Ads services.
     • False Path: Send a tailored email for SEO services.
     • Email Content: Dynamic content based on the service requested.
     • Functions: Using functions to manipulate data, e.g., extracting only the first name from "Full Name" using .split(' ')[0].
  6. Action: Merge Paths:
     • Node Type: Flow -> Merge.
     • Operation: "Append with two inputs."
     • Purpose: Combining the "true" and "false" paths of the If statement back into a single stream.
  7. Action: Update Google Sheets:
     • Node Type: Action in App (Google Sheets).
     • Operation: "Update row in sheet."
     • Matching: Using "Email" as the unique identifier to find the correct row.
     • Mapping: Updating fields like "Contacted" (set to "true" after sending an email) and "Rejected" (using a function to determine rejection based on budget).
     • Function for Rejection: An IF statement within the function: if (budget >= 1000) { false } else { true }.

4. Workflow 2: Email Management System

• Objective: Automate email inbox management using AI for categorization and organization.
• Benefit: Saves 15-30 minutes daily.
• Workflow Steps:
  1. Trigger: On Message Received (Gmail):
     • Node Type: On App Event (Gmail).
     • Polling Times: Discusses the difference between instant and polling triggers. N8N uses polling for Gmail, requiring careful consideration of polling intervals to manage workflow execution limits (2,500 executions on the starter plan). A 1-hour interval is suggested as a balance. Cron expressions can be used for custom intervals.
     • Simplify Option: Unchecking "Simplify" to retrieve full email data, not just snippets.
     • Filters: Option to filter emails based on criteria like having attachments.
     • Pinned Data: Pinning a sample email for continuous testing.
  2. Action: AI Categorization (OpenAI):
     • Node Type: AI Actions (OpenAI -> Message Model).
     • Free Credits: N8N provides 100 free OpenAI credits.
     • API Key Setup: Detailed steps for obtaining an OpenAI API key and setting up credentials in N8N.
     • System Prompt: Instructions for the AI, defining categories (Promotions, Social, Personal, Sales, Miscellaneous) and providing examples for each.
     • User Message: Inputting email sender, subject, and body for AI analysis.
     • Error Handling: Addressing "bad request" errors related to free N8N AI credits and OpenAI models, suggesting the use of paid API credits if necessary.
     • Output: AI categorizes the email (e.g., "Miscellaneous").
  3. Action: Switch Statement (Routing):
     • Node Type: Flow -> Switch.
     • Purpose: Routing emails to different paths based on AI categorization.
     • Configuration: Matching the AI output (e.g., "Miscellaneous") to specific paths using "Contains" logic for the "Mime Type" or "File Name" from the trigger.
  4. Actions for Each Category (Example: Miscellaneous):
     • Node Type: Action in App (Gmail).
     • Operation: "Add label to message."
     • Label ID: Creating a custom label (e.g., "MISK 2") in Gmail and referencing it.
     • Message ID: Mapping the unique ID of the received email from the trigger.
     • Testing: Verifying the label is applied correctly.
  5. Actions for Each Category (Example: Promotions/Social):
     • Operation: "Mark message as read."
     • Operation: "Remove label from message" (e.g., removing the "Inbox" label).
     • Logic: Merging the "Promotions" and "Social" paths to apply the same actions (mark as read, remove from inbox).
  6. Actions for Each Category (Example: Personal):
     • Operation: "Create draft" (using OpenAI to generate a response).
     • AI Prompting: System prompt for AI to draft a polished response, with rules to avoid custom variables and sign off with "Best, Jonno."
     • Functions: Using functions (via ChatGPT prompt) to extract the first name from "Full Name" for personalization.
     • Draft Configuration: Including Thread ID and To address to associate the draft with the original email.
  7. Actions for Each Category (Example: Sales):
     • Operation: "Send message" (forwarding to a co-worker).
     • Configuration: Specifying recipient, subject, and message body.

5. Workflow 3: Web Scraping and Data Processing

• Objective: Scrape data from websites, process it using AI, and store it in Google Sheets.
• Use Case: Identifying potential leads (e.g., AI automation services on Upwork) and scoring them with AI.
• Workflow Steps:
  1. Trigger: Manual Trigger: For testing purposes.
  2. Action: Get Data from Google Sheets:
     • Retrieving data from the "N8N new lead sheet" created in Workflow 1.
     • Data Formats: Examining data in JSON, Schema, and Table views.
  3. Data Types Explanation:
     • String: Text, enclosed in quotes (purple).
     • Number: Numerical values, no quotes (green).
     • Boolean: True or False (green, no quotes).
     • Binary: Files (PDFs, images, etc.), represented by a box.
     • Array: Ordered lists, denoted by square brackets [].
     • Object: Key-value pairs, denoted by curly braces {}.
     • Arrays of Objects: Combining lists with structured data (e.g., a list of leads, where each lead is an object).
  4. Data Manipulation:
     • Split Out: Breaking down an array into individual items for processing (e.g., processing each lead from a list).
     • Aggregator: Combining individual items back into an array, useful for batching actions (e.g., sending a single daily report email instead of one per lead).
     • Code Node (JavaScript): Using ChatGPT to generate JavaScript code for custom data manipulation (e.g., sorting leads by budget).
  5. Web Scraping with Apify:
     • Platform: Apify.com for web scraping.
     • Free Tier: 5 free credits per month, allowing ~1,000 scrapes.
     • Apify Store: Accessing pre-built scrapers (e.g., Google Maps Scraper).
     • Integration: Installing the Apify integration in N8N.
     • Credential Setup: Connecting N8N to Apify account.
     • Actor Configuration: Specifying search terms (e.g., "Toronto Cleaners"), location, and number of results.
     • Data Output: Apify returns data, automatically splitting it into items.
  6. Action: Add/Update Google Sheets (with Apify data):
     • Operation: "Add or update row in sheet" (searches for a row based on a unique value, updates if found, creates if not).
     • Matching Column: Using "Website" as the unique identifier.
     • Mapping: Mapping scraped data (Title, Niche, Website, Phone, Score, Review Count) to Google Sheet columns.
     • Data Cleaning: Using JavaScript functions (via ChatGPT) to remove characters like '+' from phone numbers to prevent errors.
  7. Looping and Rate Limiting:
     • Loop Node: Processing items from an array one by one.
     • Weight Node: Introducing delays between loop iterations to respect API rate limits (e.g., Google Sheets has limits on requests per minute).
     • On Error Continue: Configuring nodes to continue processing even if one item fails, preventing the entire workflow from crashing.

6. Workflow 4: Telegram Bot for File Processing

• Objective: Create a Telegram bot to receive files (PDFs, images), extract data using AI, and organize it in Google Sheets.
• Workflow Steps:
  1. Trigger: On Message Received (Telegram):
     • Credential Setup: Obtaining an API token from Telegram's BotFather.
     • Polling: Similar to Gmail, Telegram triggers are polling-based.
     • File Handling: Choosing "File" type over "Photo/Video" for better processing.
     • Pinned Data: Pinning received messages for testing.
  2. Action: Switch Statement (File Type Detection):
     • Logic: Determining if the message contains an audio file (using voice object) or a text message.
     • Mime Type: Using mimeType (e.g., application/pdf, image/jpeg) or file extension to route messages.
  3. Processing Audio Files:
     • Action: Get File (Telegram): Downloading the audio file using its file_id.
     • Action: Transcribe Recording (OpenAI): Converting the audio file to text using OpenAI's transcription models.
     • Action: Edit Fields: Creating a "text" field to store the transcribed message, ensuring consistency for the AI agent.
  4. Processing Text Files:
     • Action: Edit Fields: Creating a "text" field to store the plain text message.
  5. Merge Node: Combining the processed data from both audio and text paths into a single stream, ensuring a consistent "text" key.
  6. AI Agent for Processing:
     • System Prompt: Instructing the AI agent to process the "text" data, potentially using tools for Gmail or Google Calendar.
     • Memory: Using Simple Memory with the Telegram Chat ID to retain conversation context.
     • Tools: Integrating Google Contacts (to find contact details) and Gmail (to send emails, create drafts, label emails, find emails).
     • Error Handling: Addressing issues with AI models not recognizing specific labels (e.g., "Promotional") and correcting system prompts.
     • Multi-Agent Systems: Discussing two structures:
       • Manager-Employee: A main AI agent delegating tasks to specialized sub-agents (e.g., Gmail agent, Calendar agent).
       • Sub-Workflows: Calling separate N8N workflows as tools, offering more flexibility than AI-specific tools.
  7. Calendar Agent Sub-Workflow:
     • Trigger: "When executed by another workflow."
     • Input Parameters: Defining required inputs like Chat ID and System Prompt using JSON data.
     • Tools: Google Calendar (Create Event, Find Event, Update Event, Delete Event).
     • AI Prompting: Guiding the AI agent on how to use tools, including chronological order of operations and avoiding double bookings.
     • Data Standardization: Using ChatGPT to define JSON structures for consistent data input and output.
  8. Website Chatbot Integration:
     • Embedding: Using the N8N chat node's embed code to add a chatbot to websites (demonstrated with Google Sites).
     • Public Availability: Enabling the chat node and setting the mode to "Embed Chat."
     • JavaScript Integration: Copying and pasting JavaScript code from NPM to embed the chat.
     • URL Configuration: Replacing placeholder URLs with the N8N webhook production URL.
  9. RAG System (Retrieval Augmented Generation):
     • Concept: Creating an AI chatbot trained on specific company data (contracts, invoices, FAQs) to provide accurate, context-aware answers.
     • Two Stages:
       1. Data Ingestion: Loading company data into a system.
       2. Chatbot Creation: Building the chatbot interface to query the data.
     • Data Ingestion:
       • Trigger: Manual trigger for initial setup.
       • Google Drive Integration: Detailed, step-by-step guide for setting up Google Cloud Console, enabling APIs, configuring OAuth consent screens, and creating API credentials to access Google Drive files. This involves enabling 2-factor authentication and potentially adding payment details.
       • File Extraction: Using "Extract from file" (PDF) to get text content.
       • Vector Stores:
         • Simple Vector Store: Basic storage for embeddings.
         • Embeddings Model: Using OpenAI's text embedding models to convert text into numerical representations (vectors) that capture semantic meaning.
         • Data Loaders: Using "Recursive Character Splitter" to break text into meaningful chunks while preserving semantic context, avoiding issues with character limits or sentence fragmentation.
         • Pinecone: Introducing Pinecone as a more robust, persistent vector database solution, detailing its setup process (API keys, index creation, embedding model selection).
     • Chatbot Creation:
       • Trigger: On Message (Chat).
       • AI Agent: Configuring Chat Model (OpenAI), Memory (Simple Memory), and Tools (Vector Store).
       • System Prompt: Crucial for defining the AI agent's role, goal, tools, rules (e.g., prioritize vector store data over generic AI responses), and output format.
       • Testing: Sending messages to the AI agent and observing its responses, debugging errors by refining system prompts and ensuring correct data mapping.
       • Automation: Replacing manual triggers with Google Drive triggers (on file creation in a specific folder) for automated data ingestion.
  10. AI SAS Application Development:
      • Platform: Lovable.dev for building web applications with natural language prompts.
      • Prompt Engineering: Using ChatGPT to create detailed prompts for Lovable to build specific functionalities.
      • Workflow Integration: Connecting Lovable forms to N8N webhooks for real-time data processing.
      • HTTP Requests: Using GET requests to scrape website content and POST requests to send data.
      • Data Transformation: Using "Work with HTML" to extract specific content (body) from scraped web pages, reducing data volume sent to AI.
      • AI for Content Generation: Using OpenAI to generate social media captions and images based on user input and scraped website data.
      • Response Handling: Configuring N8N webhooks to "Respond to Webhook" to send generated content back to Lovable for display.
      • JSON Formatting: Emphasizing the critical importance of valid JSON structure for data transfer between Lovable and N8N, using JSON.stringify and ChatGPT for error correction.

7. Error Handling in N8N

• Common Errors:
  • Credentials Error: Missing or invalid API keys/tokens. Solution: Re-authenticate or create new credentials.
  • Data Type Error: Mismatching data types in comparisons or operations. Solution: Use "Convert types when required" or manually ensure type consistency.
  • Undefined Error: Referencing non-existent variables. Solution: Correctly map or reference existing variables.
  • Invalid JSON: Incorrect JSON syntax (e.g., missing commas, incorrect quoting, line breaks). Solution: Use ChatGPT to validate and fix JSON.
  • Timeout Issues: Operations taking too long to complete. Solution: Implement timeouts in node settings and use "On Error Continue" to prevent workflow failure.
  • Authorization Errors: Similar to credentials, often related to permissions.
  • AI Sub-Agent Errors: Errors occurring in external or sub-workflows, often due to incorrect data mapping or system prompts. Solution: Use the "Debug in Editor" feature and analyze execution logs.
• Status Codes: Understanding common HTTP status codes (200 Success, 300 Redirect, 400 Client Error, 500 Server Error).
• Error Workflow: Setting up a dedicated workflow triggered by errors in other workflows to send notifications (email, Slack) for proactive issue resolution.
• Version Control: Utilizing the history feature to revert to previous workflow versions within a 24-hour window.

8. N8N Pricing and Self-Hosting

• Cloud vs. Self-Hosting:
  • Cloud: Easy setup (3 mins), high uptime, managed service, but incurs monthly costs (starting around $20/month for N8N).
  • Self-Hosting (Computer): Free, but requires technical setup, maintenance, and risks downtime if the computer or internet fails.
  • Self-Hosting (Cloud Server - e.g., Hostinger): Recommended for a balance of cost-effectiveness and uptime. Offers discounts (e.g., 64% off), with plans starting around $4.99/month. Requires server setup and N8N installation.
• Workflow Execution Limits: Cloud plans have limits on workflow executions (e.g., 2,500 on starter). Self-hosting bypasses these limits.
• Hostinger Setup: Step-by-step guide for setting up N8N on Hostinger, including choosing server location, N8N version, and updating the instance.

9. Conclusion and Community Resources

• Mastery: Achieving expertise in N8N through understanding core concepts and practical application.
• Community: Encouragement to join the presenter's school community for further learning, support, and networking.
• Transformations:
  • Agency Building: Guidance on starting an automation agency, with success stories of members earning significant income.
  • Business Automation: Strategies for automating existing businesses, with examples of scaling to seven figures.
• Support: Access to weekly Q&A calls, a supportive community, and numerous free blueprints and resources.
• Call to Action: Encouragement to apply learned skills, join the community, and explore the presenter's YouTube channel for more free content.