This article provides a complete, practical walkthrough of the Manual Comparedatasets Automation Triggered n8n agent. It connects HTTP Request, Webhook across approximately 1 node(s). Expect a Intermediate setup in 15-45 minutes. One‑time purchase: €29.

What This Agent Does

This agent orchestrates a reliable automation between HTTP Request, Webhook, handling triggers, data enrichment, and delivery with guardrails for errors and rate limits.

It streamlines multi‑step processes that would otherwise require manual exports, spreadsheet cleanup, and repeated API requests. By centralizing logic in n8n, it reduces context switching, lowers error rates, and ensures consistent results across teams.

Typical outcomes include faster lead handoffs, automated notifications, accurate data synchronization, and better visibility via execution logs and optional Slack/Email alerts.

How It Works

The workflow uses standard n8n building blocks like Webhook or Schedule triggers, HTTP Request for API calls, and control nodes (IF, Merge, Set) to validate inputs, branch on conditions, and format outputs. Retries and timeouts improve resilience, while credentials keep secrets safe.

Third‑Party Integrations

• HTTP Request
• Webhook

Import and Use in n8n

1. Open n8n and create a new workflow or collection.
2. Choose Import from File or Paste JSON.
3. Paste the JSON below, then click Import.
4. Show n8n JSON

   Title:  
   Automating SQL Dataset Comparison in n8n: Yearly Payment Analysis for Customers
   
   Meta Description:  
   Discover how to create an automated SQL dataset comparison workflow in n8n to analyze and compare customer payment data across multiple years using the Compare Datasets node.
   
   Keywords:  
   n8n workflow, SQL dataset comparison, MySQL automation, Compare Datasets node, data analysis, n8n use case, MySQL query automation, n8n tutorial, SQL automation, year-over-year payment insight
   
   Third-Party APIs Used:
   
   - MySQL Database (via n8n's MySQL node)
   
   —
   
   Article:
   
   Automating SQL Dataset Comparison in n8n: Yearly Payment Analysis for Customers
   
   In the realm of data analysis, comparing values across different time frames is a frequent requirement—particularly when dealing with business metrics like customer payments. By using n8n, a powerful and flexible workflow automation tool, you can automate such a comparison efficiently without writing custom scripts. In this article, we’ll walk through a real-world n8n workflow that compares customer payment totals and order counts across different years using two SQL queries and the built-in Compare Datasets node.
   
   This automated solution can answer questions like: “How did customer payments in 2004 compare to those in 2003?” or “Which customers exhibited changes in order volume from 2004 to 2005?”
   
   Let’s break down how this workflow is structured and what it accomplishes.
   
   🔧 Workflow Overview and Objectives
   
   The goal of this n8n workflow is to fetch customer payment summaries from a MySQL database across different yearly ranges—namely 2003–2004 and 2004–2005—and then compare those datasets to identify changes per customer.
   
   To do this, the workflow follows these core steps:
   
   1. Trigger the workflow manually.
   2. Query customer payment data for the years 2003 and 2004.
   3. Query customer payment data for the years 2004 and 2005.
   4. (Optionally) Transform the second dataset slightly.
   5. Compare both datasets by customerNumber and year.
   
   Here’s a detailed look at each component.
   
   ▶️ Step 1: Triggering the Workflow
   
   The workflow is triggered manually using n8n’s Manual Trigger node called:  
   ➤ When clicking "Execute Workflow"
   
   This allows a user to execute the analysis on demand when needed, serving as a convenient entry point for quick reporting tasks.
   
   📊 Step 2: First SQL Query – Payments from 2003 and 2004
   
   Using the MySQL node named:  
   ➤ Orders from 2003 and 2004  
   
   This query runs a GROUP BY operation to fetch three key metrics for each customer:
   
   - customerNumber
   - SUM(amount) as Total payments
   - COUNT(*) as order count
   - year (extracted from the paymentDate)
   
   SQL Query:
   
   ```sql
   SELECT customerNumber, SUM(amount) as Total, COUNT(*) as ordercount, YEAR(paymentDate) as year
   FROM payments
   WHERE YEAR(paymentDate) = '2003' OR YEAR(paymentDate) = '2004'
   GROUP BY customerNumber, year;
   ```
   
   ✅ The node is connected to a MySQL database running on db4free.net (as indicated by saved credentials).
   
   📊 Step 3: Second SQL Query – Payments from 2004 and 2005
   
   Another MySQL node named:  
   ➤ Orders from 2004 and 2005
   
   This query is identical in structure to the first but fetches data for years 2004 and 2005 instead.
   
   SQL Query:
   
   ```sql
   SELECT customerNumber, SUM(amount) as Total, COUNT(*) as ordercount, YEAR(paymentDate) as year
   FROM payments
   WHERE YEAR(paymentDate) = '2004' OR YEAR(paymentDate) = '2005'
   GROUP BY customerNumber, year;
   ```
   
   🔄 Step 4: Optional Value Transformation
   
   Before comparing both datasets, this workflow includes a Set node:  
   ➤ Change ordercount
   
   This node replaces the actual order count in the second dataset with a fixed value of 1. While this may not appear immediately relevant, it could be a placeholder or part of a preprocessing step for certain analytical needs, like normalizing data or highlighting changes by flagging entries.
   
   🔍 Step 5: Comparing the Datasets
   
   The final component is the Compare Datasets node:  
   ➤ Compare Datasets
   
   This built-in node allows a native way to compare the output of two previous nodes via shared key fields. In our case, the workflow compares the 2003–2004 dataset (from step 2) and the 2004–2005 dataset (post-set transformation in step 4).
   
   Merge Keys:
   - customerNumber
   - year
   
   Options:
   - multipleMatches: set to "all", allowing the node to match multiple entries per dataset record.
   
   This step enables the actual insight generation—highlighting which customers had records in both periods, and how their values (Total payments, order counts) changed over time.
   
   💡 Use Cases for This Workflow
   
   - Year-over-Year (YoY) customer spending trends.
   - Identifying customers with increasing/decreasing transactions.
   - Analyzing customer retention by checking which customers reappeared across years.
   - Preparing datasets for BI dashboards or reporting.
   
   🚀 Conclusion
   
   With this n8n workflow, you don’t need to write elaborate scripts or manage external tooling to compare SQL datasets. By leveraging n8n’s intuitive drag-and-drop interface, you can orchestrate meaningful data analysis pipelines that query, transform, and compare your data—all in one place.
   
   This specific example provides a clear pathway for comparing datasets across time by customer, but the logic can easily be adapted for product sales, regional metrics, or any other grouped business values.
   
   n8n continues to prove its worth as a robust tool for low-code automation, especially when dealing with structured data and custom logic.
   
   If you're handling MySQL data regularly and looking to automate repeat analyses or comparisons—this workflow is a great starting point.
   
   📘 Tip: Don’t forget to tailor your credentials and dataset fields to your own schema before replicating this workflow in your n8n instance!
   
   —  
   Author: n8n Assistant  
   Date: 2024

5. Set credentials for each API node (keys, OAuth) in Credentials.
6. Run a test via Execute Workflow. Inspect Run Data, then adjust parameters.
7. Enable the workflow to run on schedule, webhook, or triggers as configured.

Tips: keep secrets in credentials, add retries and timeouts on HTTP nodes, implement error notifications, and paginate large API fetches.

Validation: use IF/Code nodes to sanitize inputs and guard against empty payloads.

Why Automate This with AI Agents

AI‑assisted automations offload repetitive, error‑prone tasks to a predictable workflow. Instead of manual copy‑paste and ad‑hoc scripts, your team gets a governed pipeline with versioned state, auditability, and observable runs.

n8n’s node graph makes data flow transparent while AI‑powered enrichment (classification, extraction, summarization) boosts throughput and consistency. Teams reclaim time, reduce operational costs, and standardize best practices without sacrificing flexibility.

Compared to one‑off integrations, an AI agent is easier to extend: swap APIs, add filters, or bolt on notifications without rewriting everything. You get reliability, control, and a faster path from idea to production.

Best Practices

• Credentials: restrict scopes and rotate tokens regularly.
• Resilience: configure retries, timeouts, and backoff for API nodes.
• Data Quality: validate inputs; normalize fields early to reduce downstream branching.
• Performance: batch records and paginate for large datasets.
• Observability: add failure alerts (Email/Slack) and persistent logs for auditing.
• Security: avoid sensitive data in logs; use environment variables and n8n credentials.

FAQs

Can I swap integrations later? Yes. Replace or add nodes and re‑map fields without rebuilding the whole flow.

How do I monitor failures? Use Execution logs and add notifications on the Error Trigger path.

Does it scale? Use queues, batching, and sub‑workflows to split responsibilities and control load.

Is my data safe? Keep secrets in Credentials, restrict token scopes, and review access logs.