How to Connect Notion and Google Sheets Automatically in 2026

Notion and Google Sheets are two essential tools for organizing and leveraging data. Their complementary nature is clear: Notion excels at content management and collaboration, while Google Sheets shines in data analysis and complex calculations. Connecting both tools lets you get the best of each without duplicate data entry.

This guide details three methods to synchronize Notion and Google Sheets automatically: via Zapier, via Make (formerly Integromat), and via direct API.

Why Connect Notion and Google Sheets?

Several scenarios justify this integration:

Automated reporting: extract data from a Notion database into Google Sheets to generate charts and dashboards.
Centralized data entry: collect information via Google Forms (which writes to Sheets) and automatically inject it into a Notion database.
Cross-team collaboration: let one team work in Notion while another exploits the same data in Sheets.
Backup: duplicate Notion data into Sheets as a safety measure.

Method 1: Connect Notion and Google Sheets with Zapier

Zapier is the most accessible automation tool. The Notion ↔ Google Sheets integration is native and requires no technical skills.

Step 1: Create a Zapier Account

Visit zapier.com and create a free account. The free plan allows up to 5 Zaps with 100 tasks per month—enough to test the integration.

Step 2: Create a New Zap

Click Create a Zap from the dashboard.
A Zap consists of two parts: a Trigger and an Action.

Step 3: Configure the Trigger

To sync from Notion to Sheets, choose Notion as the trigger:

In the trigger search bar, type Notion and select it.
Among available events, choose New Database Item (for a newly created item in a Notion database).
Connect your Notion account by clicking Continue. Zapier will redirect you to a Notion authorization page. Select the relevant workspace and grant access.
Select the source Notion database.

Step 4: Configure the Action

Now set up Google Sheets as the destination action:

In the action search bar, type Google Sheets and select it.
Choose the Create Spreadsheet Row event.
Connect your Google account. Select the Google account associated with the Sheets.
Configure the parameters:
- Drive: select the Google Drive containing the file.
- Spreadsheet: choose the destination Google Sheets.
- Worksheet: select the relevant tab.
Map the columns: Zapier displays your Google Sheet columns. For each column, select the corresponding Notion field. For example:
- Column Name → Notion Title field
- Column Status → Notion Status field
- Column Date → Notion Date field

Step 5: Test and Activate

Click Test trigger to verify Zapier retrieves a Notion item.
Click Test action to verify the write to Google Sheets.
If the test succeeds, click Publish to activate the Zap.

Each new item added to the Notion database will automatically create a row in Google Sheets.

Reverse Direction: Google Sheets to Notion

To sync from Sheets to Notion, simply swap the roles:

Trigger: Google Sheets → New Spreadsheet Row
Action: Notion → Create Database Item

The configuration principle remains identical.

Zapier Limitations

The free plan is limited to 100 tasks/month.
Zaps run every 15 minutes at most on the free plan (1-2 minutes on paid plans).
Some complex Notion properties (relations, rollups) are not always natively supported.

Method 2: Connect Notion and Google Sheets with Make

Make (formerly Integromat) offers more flexibility than Zapier, thanks to its filters, conditions, and visual routing. It's the go-to tool for advanced automations.

Step 1: Create a Make Account

Visit make.com and sign up. The free plan offers 1,000 operations per month.

Step 2: Create a New Scenario

Click Create a new scenario.
The canvas view appears: this is where you build your flow visually.

Step 3: Add the Notion Module

Click the + in the center of the canvas.
Search for Notion and add it.
Select the Watch Database Items module.
Connect your Notion account via OAuth.
Select the source database.
Optional: configure a filter to only sync certain items (e.g., only those with status "Published").

Step 4: Add the Google Sheets Module

Click the + to the right of the Notion module.
Search for Google Sheets and add it.
Select the Add a Row module.
Connect your Google account.
Select the spreadsheet, tab, and columns as with Zapier.
Map each column with data from the Notion module.

Step 5: Add Filters and Conditions (Advanced)

One of Make's major advantages is the ability to add filters between modules:

Filter by status: only sync Notion items with status "Done".
Filter by date: only sync items created after a certain date.
Routing: use a Router to send data to different Sheets tabs based on conditions.

Routing example:

Add a Router module between Notion and Sheets.
Branch two paths:
- Path A: if Type = "Client" → add to "Clients" sheet
- Path B: if Type = "Internal" → add to "Internal" sheet

Step 6: Test and Activate

Click Run once to test the scenario with real data.
Verify the results in Google Sheets.
Activate the scenario by toggling the ON switch.

Make Advantages over Zapier

More free operations: 1,000 operations/month vs 100 tasks/month.
Native filters: condition execution without an additional Zap.
Visual routing: direct data to multiple destinations.
Faster execution: scenarios run almost in real time.
More competitive pricing for high volumes.

Method 3: Connect Notion and Google Sheets via API

For advanced use cases requiring full control, direct API connection is the most powerful solution. It involves programming but offers unlimited flexibility.

Prerequisites

A Notion account with developer access.
A Google Cloud project with the Google Sheets API enabled.
Basic knowledge of JavaScript (Node.js) or Python.

Step 1: Get a Notion API Key

Visit notion.so/my-integrations.
Click New integration.
Name the integration and select the workspace.
Note the API key (starting with ntn_ or secret_).
Important: share the Notion database with this integration. Open the database in Notion → ··· menu → Connections → add your integration.

Step 2: Configure the Google Sheets API

Access the Google Cloud Console.
Create a project (or select an existing one).
Enable the Google Sheets API.
Create Service Account credentials.
Download the JSON file containing the private key.
Important: share the Google Sheet with the Service Account email (found in the JSON file, client_email field).

Step 3: Install Dependencies

npm init -y
npm install @notionhq/client googleapis

Step 4: Sync Script Notion → Sheets

const { Client } = require('@notionhq/client');
const { google } = require('googleapis');
const fs = require('fs');

// Notion configuration
const notion = new Client({ auth: process.env.NOTION_API_KEY });
const DATABASE_ID = process.env.NOTION_DATABASE_ID;

// Google Sheets configuration
const auth = new google.auth.GoogleAuth({
  keyFile: 'credentials.json',
  scopes: ['https://www.googleapis.com/auth/spreadsheets'],
});
const sheets = google.sheets({ version: 'v4', auth });

const SPREADSHEET_ID = process.env.GOOGLE_SHEET_ID;
const SHEET_NAME = 'Sheet1';

async function syncNotionToSheets() {
  // Fetch items from Notion database
  const response = await notion.databases.query({
    database_id: DATABASE_ID,
  });

  // Prepare rows for Google Sheets
  const rows = response.results.map(page => {
    const props = page.properties;
    return [
      props.Title?.title?.[0]?.plain_text || '',
      props.Status?.select?.name || '',
      props.Date?.date?.start || '',
      props.Priority?.select?.name || '',
    ];
  });

  // Write to Google Sheets
  await sheets.spreadsheets.values.update({
    spreadsheetId: SPREADSHEET_ID,
    range: `${SHEET_NAME}!A2:D${rows.length + 1}`,
    valueInputOption: 'RAW',
    requestBody: {
      values: rows,
    },
  });

  console.log(`✅ ${rows.length} rows synchronized`);
}

syncNotionToSheets().catch(console.error);

Step 5: Automate Execution

Schedule the script with cron (Linux) or GitHub Actions (cloud).

With cron (every hour):

crontab -e
# Add:
0 * * * * cd /path/to/project && node sync.js

With GitHub Actions: Create a .github/workflows/sync.yml file:

name: Sync Notion → Sheets

on:
  schedule:
    - cron: '0 * * * *'  # Every hour
  workflow_dispatch:       # Manual trigger

jobs:
  sync:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm install
      - run: node sync.js
        env:
          NOTION_API_KEY: ${{ secrets.NOTION_API_KEY }}
          NOTION_DATABASE_ID: ${{ secrets.NOTION_DATABASE_ID }}
          GOOGLE_SHEET_ID: ${{ secrets.GOOGLE_SHEET_ID }}

API Approach Advantages

Full control: fine-grained management of fields, filters, and logic.
Free: no third-party service subscription fees.
Customizable: add logs, notifications, and error handling.
Bidirectional: possible to sync in both directions.
Performant: near-instantaneous execution.

API Approach Disadvantages

Requires development skills.
Script maintenance is the team's responsibility.
The Notion API has rate limits (3 requests/second).

Comparison of the Three Methods

Criteria	Zapier	Make	Direct API
Difficulty	⭐ Easy	⭐⭐ Intermediate	⭐⭐⭐ Advanced
Free operations/month	100	1,000	Unlimited
Latency	1-15 min	~1 min	Near-instant
Filters/conditions	Via extra Zap	Native	Free code
Maintenance	None	Low	Technical team
Cost	$19.99/mo+	$10.59/mo+	Free (hosting)
Flexibility	Limited	Good	Total

Best Practices for Notion ↔ Sheets Synchronization

1. Normalize Data

Before connecting both tools, ensure structures match:

Notion data types (text, number, date, select) must correspond to Google Sheets column types.
Avoid calculated Notion properties (rollup, formula) as sync sources; prefer native properties.

2. Handle Updates

Unidirectional sync (creation only) is simpler. For updates:

Zapier: use the "Updated Database Item" trigger and "Update Spreadsheet Row" action.
Make: the "Watch Database Items" module also detects modifications.
API: compare Notion last_edited_time timestamps with those in Sheets.

3. Avoid Infinite Loops

In bidirectional sync, a change in Sheets can trigger a Notion update, which triggers a Sheets update, etc. To prevent this:

Add a "source" field (Notion / Sheets) and filter on it.
Use a minimum delay between executions.
Only sync one direction at a time if possible.

4. Monitor Errors

Zapier: check the failed tasks dashboard.
Make: review the scenario execution history.
API: implement a logging and alerting system (email, Slack).

FAQ

How to synchronize Notion and Google Sheets in real time?

No method offers truly real-time synchronization (instant webhook). Zapier and Make poll Notion at regular intervals. The API approach can reduce this delay to a few seconds using Notion webhooks coupled with a server.

Are Notion formulas synchronized in Sheets?

No. Calculated Notion properties (formulas, rollups) are evaluated on the Notion side. Only the resulting value is synced, not the formula itself. If an equivalent formula is needed in Sheets, it must be recreated manually.

How much does it cost to connect Notion and Google Sheets?

The API connection is entirely free. Zapier offers a free plan limited to 100 tasks/month. Make offers 1,000 operations/month for free. For professional use, expect between $10 and $25/month depending on the tool and volume.

Can I sync multiple Notion databases to a single Google Sheets?

Yes. With Make, simply add multiple Notion modules in parallel converging to the same Sheets module (via a Router). With the API, the script can query multiple Notion databases and write to different tabs of the same Sheets file.

What to do if synchronization fails?

Check the following:

The Notion integration has access to the database (check database settings → Connections).
The Google Service Account has access to the Google Sheets (check sharing settings).
The mapped columns still exist on both sides.
No API rate limit has been reached (Notion: 3 req/s, Google Sheets: 300 req/min).

Conclusion

Connecting Notion and Google Sheets automatically is an investment that quickly pays off by eliminating duplicate data entry and enabling better data exploitation. The method depends on context: Zapier for simplicity, Make for flexibility, and direct API for full control.

Regardless of the tool chosen, the key is to structure data properly upfront and regularly monitor the synchronization.