n8n + Google Sheets: The Complete Integration Guide (2026)

What it does

When someone submits a contact form, books a call, or triggers any webhook event, n8n appends a new row to a Google Sheet (the master lead list), then creates or updates the contact in HubSpot or Pipedrive. The Sheet gives the client a no-login-required view of all leads; the CRM is where the sales team works. Both stay in sync from the first moment a lead enters the system.

Node chain

Column mapping in the Google Sheets node

In the Google Sheets "Append Row" node, map fields using the "Mapping Column Mode" set to "Map Each Column Manually". This lets you control exactly which Sheet column gets which workflow value. If your Sheet has columns A–G and your webhook only provides 4 fields, unmapped columns stay empty — the row is still created correctly.

Use a Code node before the Sheets node to clean and normalize incoming data: trim whitespace, standardize phone formats, extract domain from email, set a source column to "Website Form" or "Typeform" etc. Clean data in the Sheet prevents messy CRM imports downstream.

Adding a timestamp and unique ID automatically

// In the Code node before Google Sheets
const { v4: uuidv4 } = require('crypto');
const now = new Date();
return [{
  json: {
    id: now.getTime().toString(36).toUpperCase(), // short unique ID
    ...($input.first().json), // spread all incoming fields
    createdAt: now.toISOString().split('T')[0], // YYYY-MM-DD
    source: 'Contact Form'
  }
}];

Always add a unique ID and timestamp at intake. You'll need the ID for upserts later, and timestamps are critical for lead attribution reporting.

What it does

An upsert is the most-requested Google Sheets operation: "if a row with this email already exists, update it; if not, create a new row." This prevents duplicate entries when the same person submits a form twice, fills out different forms, or triggers the same workflow from multiple sources. Without upsert logic, every event creates a new row and your Sheet fills up with duplicates the client has to clean manually.

Two approaches: built-in vs manual

Built-in "Append or Update Row" (simpler): The Google Sheets node has this operation natively. Set "Column to Match On" to your unique key (e.g., email). n8n searches for a matching row, updates it if found, appends if not. This is the right choice for 80% of upsert cases.

Manual upsert (more control): When you need different logic for new vs existing records — e.g., send a welcome email to new rows but not to updated ones — use the manual pattern:

The manual upsert pattern — key configuration

Get Rows node: Set "Filter Rows" → "Filter by Column" → column: Email, value: {{ $json.email }}. This returns all rows where the email matches. If the Sheet is large (1,000+ rows), this reads the entire sheet and filters client-side — acceptable for most use cases.

IF node condition: Check {{ $('Google Sheets').all().length }} greater than 0. If true → update branch; if false → append branch.

Update Row node: Set "Column to Match On" to email. Map only the fields you want to update — leave other columns empty so they're not overwritten.

Business value

Every client who has been running a basic "append row" workflow for more than a few months has a Sheet full of duplicates. The upsert upgrade is a natural follow-on project. It's a $400–$700 add-on to any existing Sheets workflow — quick to build once you know the pattern, and immediately visible value (a clean Sheet vs a messy one).

What it does

Many Sheets have partial data — a lead list with email and name but no company size, industry, or LinkedIn URL. Or a product sheet with SKUs but no descriptions. This workflow reads rows where specific columns are empty, sends each row's available data to an LLM, and writes the AI-generated values back to the empty cells. Runs on a schedule (daily or on-demand), so the Sheet is always enriched without manual research.

Node chain

Filtering rows that need enrichment

After the "Get Rows" node, use a Code node to filter only rows where the target column is empty:

// Filter rows where 'Industry' column is blank
const rows = $input.all();
const needsEnrichment = rows.filter(item => {
    const industry = item.json['Industry'];
    return !industry || industry.toString().trim() === '';
});

// Safety limit: process max 50 rows per run to stay within API quotas
return needsEnrichment.slice(0, 50);

The 50-row limit is important — enriching 500 rows in one run can hit both OpenAI rate limits and Google Sheets write quotas. Process in batches with a daily schedule instead.

The enrichment prompt

Specificity in the prompt determines result quality. A vague prompt ("tell me about this company") returns vague data. A specific prompt returns structured, writable data:

Based on the following information about a company contact,
provide enrichment data. Return ONLY valid JSON, no explanation.

Contact info:
- Name: {{ $json['First Name'] }} {{ $json['Last Name'] }}
- Email: {{ $json['Email'] }}
- Company: {{ $json['Company'] }}
- Website: {{ $json['Website'] }}

Return this exact JSON structure:
{
  "industry": "one of: SaaS, E-commerce, Healthcare, Finance, Real Estate, Agency, Other",
  "companySize": "one of: 1-10, 11-50, 51-200, 201-1000, 1000+",
  "seniorityLevel": "one of: Founder, C-Suite, VP/Director, Manager, Individual Contributor, Unknown",
  "linkedinDomain": "linkedin.com/company/[slug] or null if unknown",
  "confidence": "high, medium, or low"
}

After the OpenAI node, parse the JSON in a Code node with JSON.parse($input.first().json.message.content), then map each field to the corresponding Google Sheets column in the Update Row node.

Business value

Sales teams spend 2–4 hours per week researching leads manually to fill in company size, industry, and decision-maker seniority before qualifying calls. A well-built enrichment workflow eliminates this entirely. The AI enrichment idea is covered in depth in the n8n automation ideas guide — it consistently ranks as one of the highest-ROI automation projects for sales-driven businesses. On Upwork, enrichment workflows with ongoing tuning naturally become monthly retainers.

What it does

Operations teams maintain data in Google Sheets; sales teams work in HubSpot or Pipedrive. Neither team wants to use the other's tool, and manual exports create lag and errors. A bidirectional sync keeps both in agreement: Sheet updates push to CRM, CRM updates pull back to the Sheet. No export, no "which one is current?" confusion, no manual reconciliation.

Direction 1: Sheet changes → CRM

The Sheets Trigger's "Row Updated" event passes the old and new cell values. Use an IF node to check if the changed column is one that should sync to CRM (e.g., Status, Stage, Owner) — this prevents infinite loops when the other direction writes back to the Sheet and triggers this workflow again.

Direction 2: CRM changes → Sheet

Most CRMs don't provide a webhook for every field change, so poll-based sync (every 15 minutes) is the standard approach. Use HubSpot's "Get Contacts" with a "Last Modified Date" filter to fetch only records changed since the last run. Store the last-run timestamp in a single-cell Sheet tab or n8n static data.

Preventing infinite sync loops

The core problem with bidirectional sync: Direction 1 writes to CRM → CRM webhook fires → Direction 2 updates Sheet → Sheet trigger fires → Direction 1 runs again... infinite loop. Prevention strategies:

• Add a lastSyncedBy column to the Sheet. Write "n8n-crm-sync" when the CRM direction writes to it. The Sheet Trigger direction checks if lastSyncedBy === "n8n-crm-sync" and exits early if true.
• Only sync specific columns in each direction — don't sync every field bidirectionally. Status syncs Sheet→CRM; Stage syncs CRM→Sheet. Non-overlapping columns can't create loops.
• Add a minimum time gap: if a row was last synced less than 5 minutes ago, skip. Store last-sync timestamp per row.

What it does

On a schedule (daily 9am, weekly Monday, monthly 1st), n8n reads a Google Sheet, calculates summary metrics in a Code node, and sends a formatted Slack message or email with the key numbers. The team sees the weekly sales total, pipeline count, or inventory status without opening the Sheet, logging into a dashboard, or asking someone to pull the data.

Node chain

The aggregation Code node

The Code node is where the reporting logic lives. A realistic weekly sales digest:

const rows = $input.all().map(r => r.json);
const now = new Date();
const weekAgo = new Date(now - 7 * 24 * 60 * 60 * 1000);

// Filter to this week's rows
const thisWeek = rows.filter(r => new Date(r['Created Date']) >= weekAgo);

// Aggregate
const totalLeads = thisWeek.length;
const qualified = thisWeek.filter(r => r['Status'] === 'Qualified').length;
const totalValue = thisWeek.reduce((sum, r) => sum + (parseFloat(r['Deal Value']) || 0), 0);
const avgValue = totalLeads > 0 ? (totalValue / totalLeads).toFixed(0) : 0;
const topSource = /* count by source, return max */ Object.entries(
    thisWeek.reduce((acc, r) => { acc[r['Source']] = (acc[r['Source']] || 0) + 1; return acc; }, {})
).sort((a, b) => b[1] - a[1])[0]?.[0] || 'N/A';

return [{ json: { totalLeads, qualified, totalValue: totalValue.toFixed(0), avgValue, topSource } }];

Slack message format

*📊 Weekly Lead Report — Week of {{ $now.format('MMM D') }}*

Total new leads: *{{ $json.totalLeads }}*
Qualified: *{{ $json.qualified }}* ({{ ($json.qualified / $json.totalLeads * 100).toFixed(0) }}%)
Pipeline added: *${{ $json.totalValue }}*
Avg deal size: *${{ $json.avgValue }}*
Top source: *{{ $json.topSource }}*

<https://docs.google.com/spreadsheets/d/YOUR_SHEET_ID|View full report →>

Adding a direct link to the Sheet at the bottom of every digest drives adoption — team members click through to investigate outliers, which means they trust the automation instead of maintaining parallel manual reports. Pair this with Gmail automation to send the digest to stakeholders who aren't on Slack.

Business value

Operations managers at 10–50 person companies spend 1–3 hours per week manually compiling reports from Sheets. A $400–$600 reporting workflow eliminates this permanently. The strong ROI and quick build time make it an excellent first project for a new client — it builds trust fast and opens the door to the more complex sync and enrichment workflows above. The n8n freelancing guide covers using quick wins like this to establish retainer relationships.