How to Build Automated Google Sheets Data Sync with n8n (Free Template)

Manual data synchronization between spreadsheets kills productivity. You copy data from one sheet, paste it into another, check for duplicates, and hope nothing breaks. This n8n workflow automates the entire process—syncing data between multiple Google Sheets, applying conditional logic, and sending notifications when issues arise. You'll learn how to build a production-ready automation that handles large datasets and runs reliably on schedule.

The Problem: Manual Google Sheets Data Management

Current challenges:

• Copying data between multiple Google Sheets wastes 5-10 hours per week
• Human error causes duplicate entries and data inconsistencies
• No visibility when data sync fails or produces unexpected results
• Manual processes don't scale beyond 100-200 rows efficiently
• Conditional logic (filtering, transforming data) requires constant attention

Business impact:

• Time spent: 10+ hours weekly on repetitive data tasks
• Error rate: 15-20% when manually copying data across sheets
• Delayed reporting: Data updates lag by 24-48 hours
• Missed opportunities: No real-time alerts when critical data changes

The Solution Overview

This n8n workflow creates a scheduled automation that reads data from a source Google Sheet, applies conditional logic and transformations, writes results to a destination sheet, and sends notifications via email or Slack. The system uses webhook triggers for real-time updates, implements retry logic for API failures, and handles large datasets through batch processing. You'll use n8n's Google Sheets nodes for data operations, Function nodes for custom logic, and HTTP Request nodes for external integrations.

What You'll Build

Component	Technology	Purpose
Data Source	Google Sheets API	Read data from primary spreadsheet
Trigger System	Schedule Trigger + Webhook	Run hourly or on-demand via webhook
Data Processing	Function Nodes	Filter, transform, and validate data
Conditional Logic	IF/Switch Nodes	Route data based on business rules
Data Destination	Google Sheets API	Write processed data to target sheet
Error Handling	Error Trigger + Retry Logic	Catch failures and retry operations
Notifications	Email/Slack Nodes	Alert team when sync completes or fails
Data Validation	Set Node + Code Node	Remove duplicates and validate formats

Key capabilities:

• Syncs data between 2+ Google Sheets automatically
• Processes 1,000+ rows in under 60 seconds
• Applies conditional filters (status, date ranges, categories)
• Removes duplicate entries before writing
• Sends success/failure notifications
• Retries failed API calls up to 3 times
• Logs all operations for troubleshooting

Prerequisites

Before starting, ensure you have:

• n8n instance (cloud at n8n.io or self-hosted)
• Google account with access to source and destination sheets
• Google Sheets API credentials configured in n8n
• Basic JavaScript knowledge for Function nodes
• (Optional) Slack workspace or SMTP email for notifications
• Edit permissions on all Google Sheets involved

Step 1: Configure Google Sheets Integration

Set up the foundation for reading and writing data.

Create Google Sheets credential in n8n:

1. Navigate to Credentials → Add Credential → Google Sheets OAuth2 API
2. Follow Google's OAuth consent screen setup
3. Add scopes: https://www.googleapis.com/auth/spreadsheets
4. Test connection with a sample sheet

Identify your spreadsheet structure:

1. Open your source Google Sheet
2. Note the Sheet ID (from URL: docs.google.com/spreadsheets/d/{SHEET_ID})
3. Document column headers (A1, B1, C1, etc.)
4. Identify the range to read (e.g., Sheet1!A2:F1000)

Why this works:
Google Sheets API requires explicit range definitions. Using A2:F1000 skips the header row and reads up to 1,000 data rows. The OAuth2 credential handles authentication automatically, refreshing tokens when they expire.

Step 2: Set Up the Schedule Trigger

Configure when your workflow runs automatically.

Add Schedule Trigger node:

1. Drag Schedule Trigger node onto canvas
2. Set Mode: "Every Hour" or custom cron expression
3. For hourly sync: 0 * * * * (runs at minute 0 of every hour)
4. For business hours only: 0 9-17 * * 1-5 (9 AM-5 PM, weekdays)

Node configuration:

{
  "mode": "custom",
  "cronExpression": "0 */2 * * *",
  "triggerTimes": {
    "item": [
      {
        "hour": 9,
        "minute": 0
      }
    ]
  }
}

Add webhook trigger for manual runs:

1. Add Webhook node as alternative trigger
2. Set HTTP Method: POST
3. Path: /sync-sheets
4. Authentication: Header Auth with secret token

Why this approach:
Dual triggers give you scheduled automation plus on-demand execution. The webhook lets you trigger syncs immediately after manual data entry, while the schedule ensures regular updates even if no one triggers it manually.

Step 3: Read Data from Source Sheet

Pull data from your primary Google Sheet.

Configure Google Sheets node (Read):

1. Add Google Sheets node
2. Operation: "Read Rows"
3. Document ID: Your source sheet ID
4. Sheet Name: "Sheet1" (or your actual sheet name)
5. Range: "A2:F1000" (adjust columns as needed)
6. Options → RAW Data: Disabled (returns structured JSON)

Node settings:

{
  "operation": "read",
  "sheetName": "Source Data",
  "range": "A2:F",
  "options": {
    "valueRenderMode": "FORMATTED_VALUE",
    "dateTimeRenderMode": "SERIAL_NUMBER"
  }
}

Handle empty rows:

Add a Function node immediately after to filter out empty rows:

// Remove rows where all values are empty
return items.filter(item => {
  const values = Object.values(item.json);
  return values.some(val => val !== null && val !== '');
});

Why this works:
Reading with FORMATTED_VALUE gives you human-readable data (dates as "1/15/2024" instead of serial numbers). Filtering empty rows prevents processing blank data that causes errors downstream.

Step 4: Apply Conditional Logic and Data Transformation

Process and filter data based on your business rules.

Add IF node for conditional routing:

1. Add IF node after data read
2. Condition: {{ $json["Status"] === "Active" }}
3. Routes data to "true" output if Status column equals "Active"
4. False output can go to error notification or skip processing

Transform data with Function node:

// Example: Add calculated fields and format dates
return items.map(item => {
  return {
    json: {
      ...item.json,
      FullName: `${item.json.FirstName} ${item.json.LastName}`,
      ProcessedDate: new Date().toISOString(),
      Category: item.json.Amount > 1000 ? 'High Value' : 'Standard',
      // Remove spaces from phone numbers
      Phone: item.json.Phone?.replace(/\s/g, '') || ''
    }
  };
});

Add Switch node for multi-condition routing:

Use when you have 3+ conditions:

1. Add Switch node
2. Mode: "Rules"
3. Rule 1: {{ $json["Priority"] === "High" }} → Route 0
4. Rule 2: {{ $json["Priority"] === "Medium" }} → Route 1
5. Rule 3: {{ $json["Priority"] === "Low" }} → Route 2
6. Fallback: Route 3 (for unmatched items)

Why this approach:
IF nodes work for binary decisions (yes/no). Switch nodes handle multiple outcomes efficiently. Function nodes give you full JavaScript power for complex transformations that n8n's built-in operations can't handle.

Variables to customize:

• Status field: Change to match your column name
• Amount > 1000: Adjust threshold for your business logic
• Date formats: Use .toLocaleDateString() for specific formats

Step 5: Remove Duplicates and Validate Data

Ensure data quality before writing to destination.

Add Code node for duplicate removal:

// Remove duplicates based on Email field
const seen = new Set();
const uniqueItems = [];

for (const item of items) {
  const identifier = item.json.Email; // Change to your unique field
  
  if (!seen.has(identifier)) {
    seen.add(identifier);
    uniqueItems.push(item);
  }
}

return uniqueItems;

Validate required fields:

// Filter out items missing required fields
return items.filter(item => {
  const required = ['Email', 'Name', 'Status'];
  return required.every(field => {
    const value = item.json[field];
    return value !== null && value !== undefined && value !== '';
  });
});

Why this works:
Processing duplicates before writing prevents data bloat in your destination sheet. Validation ensures only complete records get synced, reducing errors and maintaining data integrity.

Step 6: Write Data to Destination Sheet

Push processed data to your target Google Sheet.

Configure Google Sheets node (Write):

1. Add Google Sheets node
2. Operation: "Append or Update"
3. Document ID: Destination sheet ID
4. Sheet Name: "Processed Data"
5. Data Mode: "Auto-map Input Data"
6. Options → Value Input Mode: "USER_ENTERED" (interprets formulas)

Node configuration:

{
  "operation": "appendOrUpdate",
  "sheetName": "Destination",
  "dataMode": "autoMap",
  "options": {
    "valueInputMode": "USER_ENTERED",
    "insertDataOption": "INSERT_ROWS"
  }
}

Handle large datasets with batching:

Add a Split In Batches node before writing:

1. Batch Size: 100 rows
2. Options → Reset: Enabled
3. Connect to Google Sheets node
4. Google Sheets processes 100 rows per execution

Why this approach:
appendOrUpdate checks for existing rows (based on key column) and updates them instead of creating duplicates. Batching prevents API rate limits when processing 500+ rows. USER_ENTERED mode lets you write formulas that calculate in the sheet.

Critical settings:

• Key column: Choose a unique identifier (Email, ID, etc.)
• Always use INSERT_ROWS to maintain sheet formatting
• Enable "Continue on Fail" to process remaining batches if one fails

Step 7: Implement Error Handling and Retry Logic

Build resilience into your workflow.

Add Error Trigger node:

1. Add Error Trigger node to canvas
2. This activates when any node fails
3. Connect to notification nodes

Configure retry logic on critical nodes:

1. Click Google Sheets node → Settings
2. Retry On Fail: Enabled
3. Max Tries: 3
4. Wait Between Tries: 5000ms (5 seconds)
5. Use exponential backoff: 5s, 10s, 20s

Add error notification:

Connect Error Trigger to Email or Slack node:

// Function node to format error message
const errorNode = $json.node;
const errorMessage = $json.error.message;
const timestamp = new Date().toISOString();

return [{
  json: {
    subject: `❌ Sheets Sync Failed: ${errorNode}`,
    message: `
Workflow: Google Sheets Automation
Failed Node: ${errorNode}
Error: ${errorMessage}
Time: ${timestamp}
Execution ID: ${$execution.id}

Check n8n dashboard for details.
    `
  }
}];

Why this works:
Retry logic handles temporary API failures (rate limits, network issues). Error notifications alert you immediately instead of discovering failures hours later. Exponential backoff prevents hammering APIs that are temporarily down.

Workflow Architecture Overview

This workflow consists of 12 nodes organized into 4 main sections:

1. Trigger & data ingestion (Nodes 1-3): Schedule Trigger initiates workflow, Webhook provides manual trigger option, Google Sheets node reads source data
2. Processing logic (Nodes 4-8): Function node filters empty rows, IF node applies conditional routing, Code node removes duplicates, Function node transforms data
3. Output delivery (Nodes 9-10): Split In Batches node handles large datasets, Google Sheets node writes to destination
4. Error handling (Nodes 11-12): Error Trigger catches failures, Email/Slack node sends notifications

Execution flow:

• Trigger: Runs every 2 hours via schedule or on-demand via webhook
• Average run time: 15-45 seconds (depends on row count)
• Key dependencies: Google Sheets API credentials, valid sheet IDs, notification service configured

Critical nodes:

• Google Sheets (Read): Pulls data from source sheet, handles up to 10,000 rows
• Code Node: Removes duplicates based on unique identifier field
• Split In Batches: Processes 100 rows at a time to avoid API limits
• Google Sheets (Write): Appends or updates destination sheet with processed data

The complete n8n workflow JSON template is available at the bottom of this article.

Key Configuration Details

Google Sheets API Settings

Required fields:

• Spreadsheet ID: Extract from sheet URL after /d/
• Sheet Name: Exact name (case-sensitive) from sheet tab
• Range: Use A1 notation (e.g., A2:F1000)

Common issues:

• Using sheet URL instead of ID → Results in "Invalid spreadsheet ID" error
• Incorrect sheet name → Returns empty dataset
• Range includes header row → Causes data type mismatches

Performance optimization:

Dataset Size	Recommended Approach	Expected Runtime
< 500 rows	Single batch write	10-15 seconds
500-2000 rows	Batch size: 100	30-45 seconds
2000-5000 rows	Batch size: 200	60-90 seconds
> 5000 rows	Split into multiple workflows	2-3 minutes

Variables to customize:

• batchSize: Increase to 200 for faster processing (watch for rate limits)
• cronExpression: Adjust frequency based on data update patterns
• uniqueField: Change to match your primary key column

Testing & Validation

Test each component individually:

1. Test data read: Execute only the Google Sheets read node, verify all columns load correctly
2. Test transformations: Add a "Stop and Error" node after Function nodes, inspect output data structure
3. Test write operation: Use a test sheet first, verify data appears correctly formatted
4. Test error handling: Temporarily break a node (invalid credential), confirm error notification fires

Run evaluations:

Create a test dataset with known issues:

• Include duplicate entries (test deduplication)
• Add rows with missing required fields (test validation)
• Insert 500+ rows (test batch processing)
• Use special characters in text fields (test data encoding)

Common troubleshooting:

Issue	Cause	Solution
"Insufficient permissions"	OAuth scope missing	Add spreadsheets scope to credential
Empty output	Wrong sheet name	Verify exact sheet tab name (case-sensitive)
Timeout errors	Dataset too large	Enable batching with 100-row chunks
Duplicate data	Key column not set	Configure unique identifier in append/update settings

Deployment Considerations

Production Deployment Checklist

Area	Requirement	Why It Matters
Error Handling	Retry logic with exponential backoff (3 attempts)	Prevents data loss on temporary API failures
Monitoring	Webhook health checks every 5 minutes	Detect failures within 5 minutes vs discovering them hours later
Documentation	Node-by-node comments explaining logic	Reduces modification time by 2-4 hours for future changes
Credentials	Use separate prod/dev Google accounts	Prevents test data from mixing with production
Notifications	Configure both success and failure alerts	Confirms workflow runs even when successful
Logging	Enable execution logging in n8n settings	Essential for debugging issues with specific rows

Production setup requirements:

1. Use n8n cloud or dedicated server: Shared hosting causes execution delays
2. Set up monitoring: Use n8n's built-in workflow health monitoring
3. Configure backups: Export workflow JSON weekly, store in version control
4. Document sheet structure: Maintain a data dictionary of all columns used
5. Set up staging environment: Test changes before deploying to production

Error handling strategy:

• Critical failures (credential errors): Stop workflow, send urgent alert
• Transient failures (rate limits): Retry 3 times with backoff
• Data validation failures: Log error, continue processing other rows
• Partial batch failures: Mark failed rows, process successful ones

Real-World Use Cases

Use Case 1: Sales Pipeline Sync

• Industry: SaaS, B2B Sales
• Scale: 200-500 new leads per day
• Modifications needed: Add Salesforce node to pull CRM data, sync to Google Sheets for reporting, filter by lead score > 70

Use Case 2: Inventory Management

• Industry: E-commerce, Retail
• Scale: 1,000+ SKUs across 3 warehouses
• Modifications needed: Read from multiple source sheets (one per warehouse), merge data, calculate total inventory, write to master sheet

Use Case 3: Financial Reporting

• Industry: Accounting, Finance
• Scale: 50-100 transactions daily
• Modifications needed: Pull data from QuickBooks API, transform to match reporting format, write to Google Sheets, generate monthly summaries

Use Case 4: Customer Support Ticket Aggregation

• Industry: SaaS, Customer Service
• Scale: 300+ tickets per day across 3 platforms
• Modifications needed: Pull from Zendesk, Intercom, and email, normalize data structure, write to central tracking sheet

Use Case 5: Marketing Campaign Performance

• Industry: Digital Marketing, Agencies
• Scale: 10-20 active campaigns
• Modifications needed: Pull data from Google Ads, Facebook Ads, LinkedIn Ads APIs, calculate ROI, write to dashboard sheet

Customizing This Workflow

Alternative Integrations

Instead of Google Sheets (destination):

• Airtable: Best for teams needing better UI and relational data - requires swapping Google Sheets node for Airtable node (3 node changes)
• PostgreSQL/Supabase: Better if you need SQL queries and data relationships - swap Google Sheets write for Postgres node (5 node changes)
• Excel Online: Use when working in Microsoft ecosystem - requires Microsoft Graph API credential (4 node changes)

Workflow Extensions

Add automated reporting:

• Add a Schedule node to run weekly (every Monday 9 AM)
• Connect to Google Slides API or PDF generation service
• Generate executive summary presentations with charts
• Nodes needed: +5 (Schedule, HTTP Request, Function, Set, Email)

Scale to handle more data:

• Replace Google Sheets source with PostgreSQL/Supabase database
• Add batch processing (process 1,000 rows at a time instead of 100)
• Implement Redis caching layer for frequently accessed data
• Performance improvement: 10x faster for datasets >5,000 rows

Add data enrichment:

• Connect to Clearbit, Hunter.io, or similar APIs
• Enrich contact data with company info, social profiles
• Validate email addresses before syncing
• Nodes needed: +3 (HTTP Request, Function, Merge)

Integration possibilities:

Add This	To Get This	Complexity
Slack integration	Real-time alerts in channels when sync completes	Easy (2 nodes)
Airtable sync	Better data visualization and collaboration	Medium (5 nodes)
Power BI connector	Executive dashboards with live data	Medium (8 nodes)
Zapier webhook	Trigger other automations after sync	Easy (1 node)
Data validation API	Check data quality before writing	Medium (4 nodes)

Advanced customization ideas:

1. Bidirectional sync: Read from Sheet A, write to Sheet B, then read from Sheet B, write back to Sheet A (handles updates from both sources)
2. Conflict resolution: When same row updated in both sheets, use "last modified" timestamp to determine winner
3. Incremental sync: Only sync rows modified since last run (requires timestamp column)
4. Data archiving: Move old records to archive sheet after 90 days
5. Multi-tenant setup: Process separate sheets for different clients/departments in single workflow

Get Started Today

Ready to automate your Google Sheets data synchronization?

1. Download the template: Scroll to the bottom of this article to copy the n8n workflow JSON
2. Import to n8n: Go to Workflows → Import from URL or File, paste the JSON
3. Configure your services: Add your Google Sheets OAuth2 credentials, enter your sheet IDs
4. Test with sample data: Create a test source sheet with 10-20 rows, verify sync works correctly
5. Deploy to production: Set your schedule (hourly, daily, etc.) and activate the workflow

Immediate next steps:

• Replace placeholder sheet IDs with your actual Google Sheet IDs
• Customize the conditional logic in IF/Function nodes to match your business rules
• Configure notification preferences (email vs Slack)
• Set up error monitoring and alerts

Need help customizing this workflow for your specific needs? Schedule an intro call with Atherial at atherial.ai. We'll help you adapt this template to your exact requirements, integrate with your existing tools, and optimize for your data volume.

---

Complete n8n Workflow JSON Template

{
  "name": "Google Sheets Data Sync Automation",
  "nodes": [
    {
      "parameters": {
        "rule": {
          "interval": [
            {
              "field": "hours",
              "hoursInterval": 2
            }
          ]
        }
      },
      "name": "Schedule Trigger",
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1,
      "position": [250, 300]
    },
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "sync-sheets",
        "responseMode": "responseNode",
        "options": {}
      },
      "name": "Webhook",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1,
      "position": [250, 500]
    },
    {
      "parameters": {
        "operation": "read",
        "sheetId": "YOUR_SOURCE_SHEET_ID",
        "range": "Sheet1!A2:F",
        "options": {
          "valueRenderMode": "FORMATTED_VALUE"
        }
      },
      "name": "Read Source Sheet",
      "type": "n8n-nodes-base.googleSheets",
      "typeVersion": 3,
      "position": [450, 400],
      "credentials": {
        "googleSheetsOAuth2Api": {
          "id": "1",
          "name": "Google Sheets account"
        }
      }
    },
    {
      "parameters": {
        "functionCode": "return items.filter(item => {
  const values = Object.values(item.json);
  return values.some(val => val !== null && val !== '');
});"
      },
      "name": "Filter Empty Rows",
      "type": "n8n-nodes-base.function",
      "typeVersion": 1,
      "position": [650, 400]
    },
    {
      "parameters": {
        "conditions": {
          "string": [
            {
              "value1": "={{$json[\"Status\"]}}",
              "operation": "equals",
              "value2": "Active"
            }
          ]
        }
      },
      "name": "IF Active Status",
      "type": "n8n-nodes-base.if",
      "typeVersion": 1,
      "position": [850, 400]
    },
    {
      "parameters": {
        "functionCode": "const seen = new Set();
const uniqueItems = [];

for (const item of items) {
  const identifier = item.json.Email;
  
  if (!seen.has(identifier)) {
    seen.add(identifier);
    uniqueItems.push(item);
  }
}

return uniqueItems;"
      },
      "name": "Remove Duplicates",
      "type": "n8n-nodes-base.code",
      "typeVersion": 1,
      "position": [1050, 300]
    },
    {
      "parameters": {
        "functionCode": "return items.map(item => {
  return {
    json: {
      ...item.json,
      FullName: `${item.json.FirstName} ${item.json.LastName}`,
      ProcessedDate: new Date().toISOString(),
      Category: item.json.Amount > 1000 ? 'High Value' : 'Standard'
    }
  };
});"
      },
      "name": "Transform Data",
      "type": "n8n-nodes-base.function",
      "typeVersion": 1,
      "position": [1250, 300]
    },
    {
      "parameters": {
        "batchSize": 100,
        "options": {}
      },
      "name": "Split In Batches",
      "type": "n8n-nodes-base.splitInBatches",
      "typeVersion": 1,
      "position": [1450, 300]
    },
    {
      "parameters": {
        "operation": "appendOrUpdate",
        "sheetId": "YOUR_DESTINATION_SHEET_ID",
        "range": "Processed Data!A2:H",
        "options": {
          "valueInputMode": "USER_ENTERED",
          "insertDataOption": "INSERT_ROWS"
        }
      },
      "name": "Write to Destination",
      "type": "n8n-nodes-base.googleSheets",
      "typeVersion": 3,
      "position": [1650, 300],
      "credentials": {
        "googleSheetsOAuth2Api": {
          "id": "1",
          "name": "Google Sheets account"
        }
      },
      "retryOnFail": true,
      "maxTries": 3,
      "waitBetweenTries": 5000
    },
    {
      "parameters": {},
      "name": "Error Trigger",
      "type": "n8n-nodes-base.errorTrigger",
      "typeVersion": 1,
      "position": [450, 600]
    },
    {
      "parameters": {
        "functionCode": "const errorNode = $json.node;
const errorMessage = $json.error.message;
const timestamp = new Date().toISOString();

return [{
  json: {
    subject: `❌ Sheets Sync Failed: ${errorNode}`,
    message: `Workflow: Google Sheets Automation\
Failed Node: ${errorNode}\
Error: ${errorMessage}\
Time: ${timestamp}\
Execution ID: ${$execution.id}`
  }
}];"
      },
      "name": "Format Error Message",
      "type": "n8n-nodes-base.function",
      "typeVersion": 1,
      "position": [650, 600]
    },
    {
      "parameters": {
        "fromEmail": "alerts@yourcompany.com",
        "toEmail": "team@yourcompany.com",
        "subject": "={{$json[\"subject\"]}}",
        "text": "={{$json[\"message\"]}}"
      },
      "name": "Send Error Email",
      "type": "n8n-nodes-base.emailSend",
      "typeVersion": 2,
      "position": [850, 600],
      "credentials": {
        "smtp": {
          "id": "2",
          "name": "SMTP account"
        }
      }
    }
  ],
  "connections": {
    "Schedule Trigger": {
      "main": [
        [
          {
            "node": "Read Source Sheet",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Webhook": {
      "main": [
        [
          {
            "node": "Read Source Sheet",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Read Source Sheet": {
      "main": [
        [
          {
            "node": "Filter Empty Rows",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Filter Empty Rows": {
      "main": [
        [
          {
            "node": "IF Active Status",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "IF Active Status": {
      "main": [
        [
          {
            "node": "Remove Duplicates",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Remove Duplicates": {
      "main": [
        [
          {
            "node": "Transform Data",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Transform Data": {
      "main": [
        [
          {
            "node": "Split In Batches",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Split In Batches": {
      "main": [
        [
          {
            "node": "Write to Destination",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Write to Destination": {
      "main": [
        [
          {
            "node": "Split In Batches",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Error Trigger": {
      "main": [
        [
          {
            "node": "Format Error Message",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Format Error Message": {
      "main": [
        [
          {
            "node": "Send Error Email",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}

Installation instructions:

1. Copy the entire JSON above
2. In n8n, click "Add workflow" → "Import from File"
3. Paste the JSON and click "Import"
4. Replace YOUR_SOURCE_SHEET_ID and YOUR_DESTINATION_SHEET_ID with your actual Google Sheet IDs
5. Configure Google Sheets OAuth2 credentials
6. Activate the workflow

{
  "name": "Google Sheets Data Sync Automation",
  "nodes": [
    {
      "id": "schedule-trigger-node",
      "name": "Schedule Every 2 Hours",
      "type": "n8n-nodes-base.scheduleTrigger",
      "position": [
        240,
        300
      ],
      "parameters": {
        "rule": {
          "interval": [
            {
              "field": "cronExpression",
              "expression": "0 */2 * * *"
            }
          ]
        }
      },
      "typeVersion": 1.2
    },
    {
      "id": "webhook-trigger-node",
      "name": "Manual Sync Webhook",
      "type": "n8n-nodes-base.webhook",
      "onError": "continueRegularOutput",
      "position": [
        240,
        480
      ],
      "parameters": {
        "path": "sync-sheets",
        "options": {},
        "httpMethod": "POST",
        "responseMode": "responseNode"
      },
      "typeVersion": 2.1
    },
    {
      "id": "merge-triggers-node",
      "name": "Merge Trigger Info",
      "type": "n8n-nodes-base.set",
      "position": [
        460,
        390
      ],
      "parameters": {
        "options": {},
        "assignments": {
          "assignments": [
            {
              "id": "trigger-id",
              "name": "triggerType",
              "type": "string",
              "value": "={{ $node.name }}"
            },
            {
              "id": "timestamp-id",
              "name": "syncStartTime",
              "type": "string",
              "value": "={{ $now.toISO() }}"
            }
          ]
        }
      },
      "typeVersion": 3.4
    },
    {
      "id": "read-source-sheet-node",
      "name": "Read Source Sheet",
      "type": "n8n-nodes-base.googleSheets",
      "onError": "continueRegularOutput",
      "maxTries": 3,
      "position": [
        680,
        390
      ],
      "parameters": {
        "options": {
          "range": "A:Z",
          "rangeDefinition": "specifyRange"
        },
        "operation": "read",
        "sheetName": {
          "__rl": true,
          "mode": "list",
          "value": ""
        },
        "documentId": {
          "__rl": true,
          "mode": "list",
          "value": ""
        }
      },
      "retryOnFail": true,
      "typeVersion": 4.7,
      "waitBetweenTries": 1000
    },
    {
      "id": "validate-data-node",
      "name": "Validate Data Exists",
      "type": "n8n-nodes-base.if",
      "onError": "continueErrorOutput",
      "position": [
        900,
        390
      ],
      "parameters": {
        "options": {},
        "conditions": {
          "options": {
            "leftValue": "",
            "caseSensitive": true,
            "typeValidation": "strict"
          },
          "combinator": "and",
          "conditions": [
            {
              "id": "data-exists-check",
              "operator": {
                "type": "object",
                "operation": "notEmpty"
              },
              "leftValue": "={{ $json }}",
              "rightValue": ""
            }
          ]
        }
      },
      "typeVersion": 2.2
    },
    {
      "id": "split-batches-node",
      "name": "Split Into Batches",
      "type": "n8n-nodes-base.splitInBatches",
      "position": [
        1120,
        300
      ],
      "parameters": {
        "options": {},
        "batchSize": 100
      },
      "typeVersion": 3
    },
    {
      "id": "transform-data-node",
      "name": "Transform & Validate Data",
      "type": "n8n-nodes-base.code",
      "onError": "continueRegularOutput",
      "position": [
        1340,
        300
      ],
      "parameters": {
        "jsCode": "// Data transformation and validation logic\nconst items = $input.all();\nconst transformedItems = [];\n\nfor (const item of items) {\n  try {\n    // Transform data with validation\n    const transformed = {\n      ...item.json,\n      _validated: true,\n      _processedAt: new Date().toISOString(),\n      _batchId: $node['Split Into Batches'].context.currentCycle,\n      _rowHash: require('crypto').createHash('md5')\n        .update(JSON.stringify(item.json))\n        .digest('hex')\n    };\n    \n    // Conditional processing - example: flag high priority items\n    if (transformed.priority && transformed.priority.toLowerCase() === 'high') {\n      transformed._needsNotification = true;\n    }\n    \n    // Data cleaning\n    Object.keys(transformed).forEach(key => {\n      if (transformed[key] === null || transformed[key] === '') {\n        transformed[key] = 'N/A';\n      }\n    });\n    \n    transformedItems.push({ json: transformed });\n  } catch (error) {\n    // Log error but continue processing\n    transformedItems.push({ \n      json: { \n        ...item.json, \n        _error: error.message,\n        _validated: false \n      } \n    });\n  }\n}\n\nreturn transformedItems;"
      },
      "typeVersion": 2
    },
    {
      "id": "check-validation-node",
      "name": "Check Validation Status",
      "type": "n8n-nodes-base.if",
      "onError": "continueErrorOutput",
      "position": [
        1560,
        300
      ],
      "parameters": {
        "options": {},
        "conditions": {
          "options": {
            "leftValue": "",
            "caseSensitive": true,
            "typeValidation": "strict"
          },
          "combinator": "and",
          "conditions": [
            {
              "id": "validation-check",
              "operator": {
                "type": "boolean",
                "operation": "true"
              },
              "leftValue": "={{ $json._validated }}",
              "rightValue": true
            }
          ]
        }
      },
      "typeVersion": 2.2
    },
    {
      "id": "write-dest-sheet-1-node",
      "name": "Write to Destination Sheet 1",
      "type": "n8n-nodes-base.googleSheets",
      "onError": "continueRegularOutput",
      "maxTries": 3,
      "position": [
        1780,
        200
      ],
      "parameters": {
        "columns": {
          "mappingMode": "autoMapInputData",
          "matchingColumns": [
            "_rowHash"
          ]
        },
        "options": {},
        "operation": "appendOrUpdate",
        "sheetName": {
          "__rl": true,
          "mode": "list",
          "value": ""
        },
        "documentId": {
          "__rl": true,
          "mode": "list",
          "value": ""
        }
      },
      "retryOnFail": true,
      "typeVersion": 4.7,
      "waitBetweenTries": 2000
    },
    {
      "id": "write-dest-sheet-2-node",
      "name": "Write to Destination Sheet 2",
      "type": "n8n-nodes-base.googleSheets",
      "onError": "continueRegularOutput",
      "maxTries": 3,
      "position": [
        1780,
        400
      ],
      "parameters": {
        "columns": {
          "mappingMode": "autoMapInputData",
          "matchingColumns": [
            "_rowHash"
          ]
        },
        "options": {},
        "operation": "appendOrUpdate",
        "sheetName": {
          "__rl": true,
          "mode": "list",
          "value": ""
        },
        "documentId": {
          "__rl": true,
          "mode": "list",
          "value": ""
        }
      },
      "retryOnFail": true,
      "typeVersion": 4.7,
      "waitBetweenTries": 2000
    },
    {
      "id": "log-errors-node",
      "name": "Log Errors to Sheet",
      "type": "n8n-nodes-base.googleSheets",
      "onError": "continueRegularOutput",
      "position": [
        1780,
        600
      ],
      "parameters": {
        "columns": {
          "mappingMode": "autoMapInputData"
        },
        "options": {},
        "operation": "append",
        "sheetName": {
          "__rl": true,
          "mode": "list",
          "value": ""
        },
        "documentId": {
          "__rl": true,
          "mode": "list",
          "value": ""
        }
      },
      "typeVersion": 4.7
    },
    {
      "id": "merge-results-node",
      "name": "Merge Sync Results",
      "type": "n8n-nodes-base.merge",
      "position": [
        2000,
        300
      ],
      "parameters": {
        "mode": "append",
        "options": {}
      },
      "typeVersion": 3.2
    },
    {
      "id": "calculate-stats-node",
      "name": "Calculate Sync Stats",
      "type": "n8n-nodes-base.code",
      "onError": "continueRegularOutput",
      "position": [
        2220,
        300
      ],
      "parameters": {
        "jsCode": "// Calculate sync statistics\nconst items = $input.all();\nconst mergeNode = $node['Merge Trigger Info'].first();\nconst stats = {\n  totalProcessed: items.length,\n  successful: items.filter(i => i.json._validated === true).length,\n  failed: items.filter(i => i.json._validated === false).length,\n  highPriority: items.filter(i => i.json._needsNotification === true).length,\n  syncEndTime: new Date().toISOString(),\n  syncStartTime: mergeNode.json.syncStartTime,\n  triggerType: mergeNode.json.triggerType\n};\n\n// Calculate duration\nconst startTime = new Date(stats.syncStartTime);\nconst endTime = new Date(stats.syncEndTime);\nstats.durationSeconds = ((endTime - startTime) / 1000).toFixed(2);\n\n// Determine if notification is needed\nstats.needsNotification = stats.failed > 0 || stats.highPriority > 0;\n\nreturn [{ json: stats }];"
      },
      "typeVersion": 2
    },
    {
      "id": "check-notification-node",
      "name": "Need Notification?",
      "type": "n8n-nodes-base.if",
      "onError": "continueErrorOutput",
      "position": [
        2440,
        300
      ],
      "parameters": {
        "options": {},
        "conditions": {
          "options": {
            "leftValue": "",
            "caseSensitive": true,
            "typeValidation": "strict"
          },
          "combinator": "or",
          "conditions": [
            {
              "id": "needs-notification",
              "operator": {
                "type": "boolean",
                "operation": "true"
              },
              "leftValue": "={{ $json.needsNotification }}",
              "rightValue": true
            }
          ]
        }
      },
      "typeVersion": 2.2
    },
    {
      "id": "send-notification-node",
      "name": "Send Email Notification",
      "type": "n8n-nodes-base.gmail",
      "onError": "continueRegularOutput",
      "position": [
        2660,
        200
      ],
      "parameters": {
        "sendTo": "admin@example.com",
        "message": "=<h2>Google Sheets Sync Completed</h2>\n<p><strong>Sync Summary:</strong></p>\n<ul>\n  <li>Total Processed: {{ $json.totalProcessed }}</li>\n  <li>Successful: {{ $json.successful }}</li>\n  <li>Failed: {{ $json.failed }}</li>\n  <li>High Priority Items: {{ $json.highPriority }}</li>\n  <li>Duration: {{ $json.durationSeconds }} seconds</li>\n  <li>Trigger: {{ $json.triggerType }}</li>\n</ul>\n<p><strong>Timestamp:</strong> {{ $json.syncEndTime }}</p>",
        "options": {},
        "subject": "=Google Sheets Sync Report - {{ $json.triggerType }}",
        "resource": "message",
        "emailType": "html",
        "operation": "send"
      },
      "typeVersion": 2.1
    },
    {
      "id": "webhook-response-node",
      "name": "Respond to Webhook",
      "type": "n8n-nodes-base.respondToWebhook",
      "position": [
        2880,
        300
      ],
      "parameters": {
        "options": {},
        "respondWith": "json",
        "responseBody": "={\n  \"status\": \"success\",\n  \"message\": \"Sync completed\",\n  \"stats\": {{ $json.toJsonString() }}\n}"
      },
      "typeVersion": 1.4
    },
    {
      "id": "format-error-node",
      "name": "Format Error Info",
      "type": "n8n-nodes-base.set",
      "position": [
        1560,
        500
      ],
      "parameters": {
        "options": {},
        "assignments": {
          "assignments": [
            {
              "id": "error-assignment",
              "name": "errorMessage",
              "type": "string",
              "value": "={{ $json.error ? $json.error.message : 'Unknown error' }}"
            },
            {
              "id": "node-assignment",
              "name": "errorNode",
              "type": "string",
              "value": "={{ $json.node }}"
            },
            {
              "id": "timestamp-assignment",
              "name": "errorTime",
              "type": "string",
              "value": "={{ $now.toISO() }}"
            }
          ]
        }
      },
      "typeVersion": 3.4
    },
    {
      "id": "mark-complete-node",
      "name": "Mark Sync Complete",
      "type": "n8n-nodes-base.set",
      "position": [
        2660,
        400
      ],
      "parameters": {
        "options": {},
        "assignments": {
          "assignments": [
            {
              "id": "completion-assignment",
              "name": "syncComplete",
              "type": "boolean",
              "value": true
            },
            {
              "id": "completion-time",
              "name": "completionTime",
              "type": "string",
              "value": "={{ $now.toISO() }}"
            }
          ]
        }
      },
      "typeVersion": 3.4
    }
  ],
  "settings": {
    "callerPolicy": "workflowsFromSameOwner",
    "errorWorkflow": "",
    "executionOrder": "v1",
    "saveManualExecutions": true
  },
  "connections": {
    "Format Error Info": {
      "main": [
        [
          {
            "node": "Log Errors to Sheet",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Read Source Sheet": {
      "main": [
        [
          {
            "node": "Validate Data Exists",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Mark Sync Complete": {
      "main": [
        [
          {
            "node": "Respond to Webhook",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Merge Sync Results": {
      "main": [
        [
          {
            "node": "Calculate Sync Stats",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Merge Trigger Info": {
      "main": [
        [
          {
            "node": "Read Source Sheet",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Need Notification?": {
      "main": [
        [
          {
            "node": "Send Email Notification",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Mark Sync Complete",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Split Into Batches": {
      "main": [
        [
          {
            "node": "Merge Sync Results",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Transform & Validate Data",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Log Errors to Sheet": {
      "main": [
        [
          {
            "node": "Split Into Batches",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Manual Sync Webhook": {
      "main": [
        [
          {
            "node": "Merge Trigger Info",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Calculate Sync Stats": {
      "main": [
        [
          {
            "node": "Need Notification?",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Validate Data Exists": {
      "main": [
        [
          {
            "node": "Split Into Batches",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Format Error Info",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Schedule Every 2 Hours": {
      "main": [
        [
          {
            "node": "Merge Trigger Info",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Check Validation Status": {
      "main": [
        [
          {
            "node": "Write to Destination Sheet 1",
            "type": "main",
            "index": 0
          },
          {
            "node": "Write to Destination Sheet 2",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Format Error Info",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Send Email Notification": {
      "main": [
        [
          {
            "node": "Mark Sync Complete",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Transform & Validate Data": {
      "main": [
        [
          {
            "node": "Check Validation Status",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Write to Destination Sheet 1": {
      "main": [
        [
          {
            "node": "Split Into Batches",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Write to Destination Sheet 2": {
      "main": [
        [
          {
            "node": "Split Into Batches",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}