Comment connecter Notion et Google Sheets automatiquement en 2026

Notion et Google Sheets sont deux outils incontournables pour organiser et exploiter des données. Leur complémentarité est évidente : Notion excelle dans la gestion de contenu et la collaboration, tandis que Google Sheets brille dans l'analyse de données et les calculs complexes. Connecter ces deux outils permet de tirer le meilleur de chacun sans double saisie.

Ce guide détaille trois méthodes pour synchroniser Notion et Google Sheets automatiquement : via Zapier, via Make (anciennement Integromat), et via API directe.

Pourquoi connecter Notion et Google Sheets ?

Plusieurs scénarios justifient cette intégration :

Reporting automatisé : extraire les données d'un tableau Notion vers un Google Sheets pour générer des graphiques et des tableaux de bord.
Saisie centralisée : collecter des informations dans Google Forms (qui écrit dans Sheets) et les injecter automatiquement dans une base Notion.
Collaboration croisée : permettre à une équipe de travailler dans Notion pendant qu'une autre exploite les mêmes données dans Sheets.
Sauvegarde : dupliquer les données Notion dans Sheets comme mesure de sécurité.

Méthode 1 : Connecter Notion et Google Sheets avec Zapier

Zapier est l'outil d'automatisation le plus accessible. L'intégration Notion ↔ Google Sheets est native et ne nécessite aucune compétence technique.

Étape 1 : Créer un compte Zapier

Rendez-vous sur zapier.com et créez un compte gratuit. Le plan gratuit permet de créer jusqu'à 5 Zaps avec 100 tâches par mois, suffisant pour tester l'intégration.

Étape 2 : Créer un nouveau Zap

Cliquez sur Create a Zap depuis le tableau de bord.
Un Zap se compose de deux parties : un déclencheur (Trigger) et une action.

Étape 3 : Configurer le déclencheur

Pour synchroniser de Notion vers Sheets, choisissez Notion comme déclencheur :

Dans la barre de recherche du déclencheur, tapez Notion et sélectionnez-le.
Parmi les événements disponibles, choisissez New Database Item (pour un élément créé dans une base de données Notion).
Connectez votre compte Notion en cliquant sur Continue. Zapier vous redirigera vers une page d'autorisation Notion. Sélectionnez le workspace concerné et autorisez l'accès.
Sélectionnez la base de données Notion source.

Étape 4 : Configurer l'action

Maintenant, configurez Google Sheets comme action de destination :

Dans la barre de recherche de l'action, tapez Google Sheets et sélectionnez-le.
Choisissez l'événement Create Spreadsheet Row (créer une ligne dans un tableur).
Connectez votre compte Google. Sélectionnez le compte Google associé aux Sheets.
Configurez les paramètres :
- Drive : sélectionnez le Google Drive contenant le fichier.
- Spreadsheet : choisissez le Google Sheets de destination.
- Worksheet : sélectionnez l'onglet concerné.
Mapper les colonnes : Zapier affiche les colonnes de votre Google Sheet. Pour chaque colonne, sélectionnez le champ Notion correspondant. Par exemple :
- Colonne Nom → champ Title de Notion
- Colonne Statut → champ Status de Notion
- Colonne Date → champ Date de Notion

Étape 5 : Tester et activer

Cliquez sur Test trigger pour vérifier que Zapier récupère bien un élément Notion existant.
Cliquez sur Test action pour vérifier l'écriture dans Google Sheets.
Si le test réussit, cliquez sur Publish pour activer le Zap.

Chaque nouvel élément ajouté à la base Notion créera automatiquement une ligne dans Google Sheets.

Sens inverse : de Google Sheets vers Notion

Pour synchroniser de Sheets vers Notion, inversez simplement les rôles :

Déclencheur : Google Sheets → New Spreadsheet Row
Action : Notion → Create Database Item

Le principe de configuration reste identique.

Limites de Zapier

Le plan gratuit est limité à 100 tâches/mois.
Les Zaps s'exécutent toutes les 15 minutes maximum sur le plan gratuit (1-2 minutes sur les plans payants).
Certaines propriétés Notion complexes (relations, rollups) ne sont pas toujours supportées nativement.

Méthode 2 : Connecter Notion et Google Sheets avec Make

Make (anciennement Integromat) offre plus de flexibilité que Zapier, notamment grâce à ses filtres, ses conditions et son routage visuel. C'est l'outil de prédilection pour les automatisations avancées.

Étape 1 : Créer un compte Make

Rendez-vous sur make.com et inscrivez-vous. Le plan gratuit offre 1 000 opérations par mois.

Étape 2 : Créer un nouveau scénario

Cliquez sur Create a new scenario.
La vue en canevas s'affiche : c'est ici que vous construirez votre flux visuellement.

Étape 3 : Ajouter le module Notion

Cliquez sur le + au centre du canevas.
Recherchez Notion et ajoutez-le.
Sélectionnez le module Watch Database Items (surveiller les nouveaux éléments).
Connectez votre compte Notion via OAuth.
Sélectionnez la base de données source.
Facultatif : configurez un filtre pour ne synchroniser que certains éléments (par exemple, uniquement ceux dont le statut est "Publié").

Étape 4 : Ajouter le module Google Sheets

Cliquez sur le + à droite du module Notion.
Recherchez Google Sheets et ajoutez-le.
Sélectionnez le module Add a Row.
Connectez votre compte Google.
Sélectionnez le tableur, l'onglet et les colonnes comme avec Zapier.
Mappez chaque colonne avec les données issues du module Notion.

Étape 5 : Ajouter des filtres et conditions (avancé)

L'un des grands avantages de Make est la possibilité d'ajouter des filtres entre les modules :

Filtre par statut : ne synchroniser que les éléments Notion avec le statut "Terminé".
Filtre par date : ne synchroniser que les éléments créés après une certaine date.
Routage : utiliser un Router pour envoyer les données vers différentes feuilles Sheets selon des conditions.

Exemple de routage :

Ajoutez un module Router entre Notion et Sheets.
Branchez deux chemins :
- Chemin A : si Type = "Client" → ajouter dans la feuille "Clients"
- Chemin B : si Type = "Interne" → ajouter dans la feuille "Interne"

Étape 6 : Tester et activer

Cliquez sur Run once pour tester le scénario avec des données réelles.
Vérifiez les résultats dans Google Sheets.
Activez le scénario en basculant l'interrupteur ON.

Avantages de Make par rapport à Zapier

Plus d'opérations gratuites : 1 000 opérations/mois vs 100 tâches/mois.
Filtres natifs : conditionner l'exécution sans Zap supplémentaire.
Routage visuel : diriger les données vers plusieurs destinations.
Exécution plus rapide : les scénarios s'exécutent presque en temps réel.
Prix plus compétitif pour les volumes importants.

Méthode 3 : Connecter Notion et Google Sheets via API

Pour les cas d'usage avancés nécessitant un contrôle total, la connexion directe via API est la solution la plus puissante. Elle implique de la programmation mais offre une flexibilité illimitée.

Prérequis

Un compte Notion avec accès développeur.
Un projet Google Cloud avec l'API Google Sheets activée.
Des connaissances de base en JavaScript (Node.js) ou Python.

Étape 1 : Obtenir une clé API Notion

Rendez-vous sur notion.so/my-integrations.
Cliquez sur New integration.
Nommez l'intégration et sélectionnez le workspace.
Notez la clé API (commençant par ntn_ ou secret_).
Important : partagez la base de données Notion avec cette intégration. Ouvrez la base dans Notion → menu ··· → Connections → ajoutez votre intégration.

Étape 2 : Configurer l'API Google Sheets

Accédez à la Google Cloud Console.
Créez un projet (ou sélectionnez un existant).
Activez l'API Google Sheets API.
Créez des identifiants de type Service Account.
Téléchargez le fichier JSON contenant la clé privée.
Important : partagez le Google Sheet avec l'email du Service Account (trouvé dans le fichier JSON, champ client_email).

Étape 3 : Installer les dépendances

npm init -y
npm install @notionhq/client googleapis

Étape 4 : Script de synchronisation Notion → Sheets

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

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

// Configuration Google Sheets
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() {
  // Récupérer les éléments de la base Notion
  const response = await notion.databases.query({
    database_id: DATABASE_ID,
  });

  // Préparer les lignes pour Google Sheets
  const rows = response.results.map(page => {
    const props = page.properties;
    return [
      props.Titre?.title?.[0]?.plain_text || '',
      props.Statut?.select?.name || '',
      props.Date?.date?.start || '',
      props.Priorite?.select?.name || '',
    ];
  });

  // Écrire dans 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} lignes synchronisées`);
}

syncNotionToSheets().catch(console.error);

Étape 5 : Automatiser l'exécution

Planifiez l'exécution du script avec cron (Linux) ou GitHub Actions (cloud).

Avec cron (toutes les heures) :

crontab -e
# Ajouter :
0 * * * * cd /chemin/du/projet && node sync.js

Avec GitHub Actions : Créez un fichier .github/workflows/sync.yml :

name: Sync Notion → Sheets

on:
  schedule:
    - cron: '0 * * * *'  # Chaque heure
  workflow_dispatch:       # Déclenchement manuel

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 }}

Avantages de l'approche API

Contrôle total : gestion fine des champs, des filtres, de la logique.
Gratuit : pas de frais d'abonnement à un service tiers.
Personnalisable : ajout de logs, de notifications, de gestion d'erreurs.
Bidirectionnel : possible de synchroniser dans les deux sens.
Performant : exécution quasi instantanée.

Inconvénients de l'approche API

Nécessite des compétences en développement.
La maintenance du script est à la charge de l'équipe.
L'API Notion a des limites de requêtes (3 requêtes/seconde).

Comparatif des trois méthodes

Critère	Zapier	Make	API directe
Difficulté	⭐ Facile	⭐⭐ Intermédiaire	⭐⭐⭐ Avancé
Opérations gratuites/mois	100	1 000	Illimité
Latence	1-15 min	~1 min	Quasi instantanée
Filtres/conditions	Via Zap additionnel	Natif	Code libre
Maintenance	Aucune	Faible	Équipe technique
Coût	$19.99/mois+	$10.59/mois+	Gratuit (hébergement)
Flexibilité	Limitée	Bonne	Totale

Bonnes pratiques pour la synchronisation Notion ↔ Sheets

1. Normaliser les données

Avant de connecter les deux outils, assurez-vous que les structures correspondent :

Les types de données Notion (texte, nombre, date, select) doivent correspondre aux types de colonnes Google Sheets.
Évitez les propriétés Notion calculées (rollup, formule) comme source de synchronisation ; préférez les propriétés natives.

2. Gérer les mises à jour

Une synchronisation unidirectionnelle (création uniquement) est plus simple. Pour les mises à jour :

Zapier : utilisez le déclencheur "Updated Database Item" et l'action "Update Spreadsheet Row".
Make : le module "Watch Database Items" détecte aussi les modifications.
API : comparez les timestamps last_edited_time de Notion avec ceux de Sheets.

3. Éviter les boucles infinies

En synchronisation bidirectionnelle, une modification dans Sheets peut déclencher une mise à jour dans Notion, qui déclenche une mise à jour dans Sheets, etc. Pour éviter cela :

Ajoutez un champ "source" (Notion / Sheets) et filtrez sur ce champ.
Utilisez un délai minimum entre les exécutions.
Ne synchronisez qu'un sens à la fois si possible.

4. Surveiller les erreurs

Zapier : consultez le tableau de bord des tâches échouées.
Make : vérifiez l'historique d'exécution du scénario.
API : implémentez un système de logs et d'alertes (email, Slack).

FAQ

Comment synchroniser en temps réel Notion et Google Sheets ?

Aucune méthode ne propose une synchronisation véritablement en temps réel (webhook instantané). Zapier et Make interrogent Notion à intervalles réguliers. L'approche API permet de réduire ce délai à quelques secondes en utilisant les webhooks de Notion couplés à un serveur.

Est-ce que les formules Notion sont synchronisées dans Sheets ?

Non. Les propriétés calculées Notion (formules, rollups) sont évaluées côté Notion. Seule la valeur résultante est synchronisée, pas la formule elle-même. Si une formule équivalente est nécessaire dans Sheets, elle devra être recréée manuellement.

Combien ça coûte de connecter Notion et Google Sheets ?

La connexion via API est entièrement gratuite. Zapier propose un plan gratuit limité à 100 tâches/mois. Make offre 1 000 opérations/mois gratuitement. Pour une utilisation professionnelle, comptez entre 10 € et 25 €/mois selon l'outil et le volume.

Peut-on synchroniser plusieurs bases Notion vers un seul Google Sheets ?

Oui. Avec Make, il suffit d'ajouter plusieurs modules Notion en parallèle qui convergent vers le même module Sheets (via un Router). Avec l'API, le script peut interroger plusieurs bases de données Notion et écrire dans différents onglets du même fichier Sheets.

Que faire si la synchronisation échoue ?

Vérifiez les points suivants :

L'intégration Notion a bien accès à la base de données (vérifiez dans les paramètres de la base → Connections).
Le Service Account Google a bien accès au Google Sheets (vérifiez les partages).
Les colonnes mappées existent toujours des deux côtés.
Aucune limite de taux API n'a été atteinte (Notion : 3 req/s, Google Sheets : 300 req/min).

Conclusion

Connecter Notion et Google Sheets automatiquement est un investissement qui se rentabilise rapidement en éliminant la double saisie et en permettant une meilleure exploitation des données. La méthode dépend du contexte : Zapier pour la simplicité, Make pour la flexibilité, et API directe pour le contrôle total.

Quel que soit l'outil choisi, la clé est de bien structurer les données en amont et de surveiller régulièrement le bon fonctionnement de la synchronisation.