Comment connecter Google Sheets à MySQL : Méthodes avec et sans code

Eliott Ardisson

Founder & CEO - Basalt Studio

Mar 12, 2026

Updated May 29, 2026

tutorials

Comment connecter Google Sheets à MySQL avec ou sans code : Apps Script, n8n, Make — méthodes comparées, erreurs à éviter et bonnes pratiques de sécurité.

ai agents

automation

programmatic

Points clés

Deux approches distinctes : Google Apps Script (gratuit, nécessite du JavaScript) et les outils d’automatisation visuelle comme n8n ou Make (payants, accessibles aux équipes non techniques).
Aucune des deux méthodes ne fait de miracle sans préparation : la qualité de la synchronisation dépend d’abord de la qualité du modèle de données MySQL et des droits d’accès configurés en amont.
La sécurité est souvent l’angle mort : identifiants stockés en dur, connexions non chiffrées, utilisateurs MySQL avec trop de privilèges — ces erreurs sont fréquentes et évitables.
Le sens de la synchronisation compte : lecture seule (MySQL → Sheets) est simple à mettre en place ; la synchronisation bidirectionnelle demande une logique de résolution de conflits.
Les outils no-code ont des limites réelles : fréquence de polling, coût par opération, volume de données — à évaluer selon votre usage avant de choisir.

Connecter Google Sheets à une base de données MySQL est une opération courante dans les PME qui veulent rendre leurs données accessibles à des équipes non techniques, sans exposer directement la base. Le cas d’usage typique : une équipe commerciale qui a besoin de consulter les données clients issues d’un ERP ou d’un CRM maison, sans passer par un développeur à chaque rapport.

Ce guide couvre les deux approches principales — avec et sans code — leurs configurations concrètes, les erreurs à éviter et les critères pour choisir entre les deux.

Ce que permet réellement cette connexion

Google Sheets n’est pas un outil BI. Il ne remplace pas un entrepôt de données ou un tableau de bord Metabase. Mais pour des équipes de 5 à 50 personnes qui travaillent déjà dans Sheets, le connecter à MySQL permet de :

Afficher des données à jour sans export CSV manuel
Permettre des saisies dans Sheets qui se répercutent dans la base
Construire des rapports dynamiques pour des profils non techniques
Automatiser des flux de validation ou d’approbation basés sur des données métier

La synchronisation peut être unidirectionnelle (MySQL vers Sheets, en lecture) ou bidirectionnelle (avec écriture dans MySQL depuis Sheets). Le deuxième cas est techniquement plus complexe et introduit des risques de conflits de données.

Prérequis avant de commencer

Avant de choisir une méthode, rassemblez les éléments suivants.

Informations de connexion MySQL :

Adresse du serveur (hostname ou IP)
Nom de la base de données
Identifiants d’un utilisateur dédié (ne jamais utiliser root)
Port (3306 par défaut)
Certificat SSL si la base est accessible depuis l’extérieur

Côté accès et sécurité :

Créez un utilisateur MySQL avec uniquement les privilèges nécessaires (SELECT pour la lecture, INSERT/UPDATE si écriture)
Vérifiez que les connexions entrantes depuis l’IP de l’outil utilisé sont autorisées dans le pare-feu
Activez SSL/TLS sur la connexion si la base est exposée sur internet

Côté données :

Identifiez les tables et colonnes à synchroniser
Définissez la fréquence de mise à jour acceptable (temps réel, toutes les heures, une fois par jour)
Vérifiez si les données contiennent des informations personnelles soumises au RGPD — cela conditionne ce que vous pouvez transférer vers Sheets

Méthode 1 : Google Apps Script

Google Apps Script est l’environnement JavaScript natif de Google Workspace. Il permet d’écrire des scripts qui s’exécutent directement dans Google Sheets, avec un accès complet à l’API Spreadsheets et à UrlFetchApp pour appeler des services externes.

Ce qu’il faut savoir d’emblée : Apps Script n’a pas de connecteur MySQL natif. Il ne peut pas ouvrir une connexion TCP directe sur le port 3306. Pour interroger MySQL depuis Apps Script, vous avez besoin d’un intermédiaire : soit une API REST que vous déployez devant votre base (sur Cloud Run, Railway, ou un VPS), soit un service tiers qui expose MySQL via HTTP.

Configuration de base

Dans votre feuille Google Sheets, allez dans Extensions > Apps Script. Supprimez la fonction par défaut et commencez par stocker vos paramètres de connexion de façon sécurisée — jamais en dur dans le code :

function getConfig() {
  const props = PropertiesService.getScriptProperties();
  return {
    apiUrl: props.getProperty('MYSQL_API_URL'),
    apiKey: props.getProperty('MYSQL_API_KEY')
  };
}

Vous renseignez ces valeurs dans Paramètres du projet > Propriétés de script, accessible depuis l’éditeur Apps Script. Elles ne sont jamais visibles dans le code versionné.

Requête vers MySQL via API REST

function fetchFromMySQL(query) {
  const config = getConfig();

  const options = {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer ' + config.apiKey
    },
    payload: JSON.stringify({ query: query }),
    muteHttpExceptions: true
  };

  const response = UrlFetchApp.fetch(config.apiUrl, options);

  if (response.getResponseCode() !== 200) {
    console.error('Erreur API:', response.getContentText());
    return null;
  }

  return JSON.parse(response.getContentText());
}

Import des données dans la feuille

function importClientsFromMySQL() {
  const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('Clients');
  const data = fetchFromMySQL('SELECT id, nom, email, date_creation FROM clients ORDER BY date_creation DESC LIMIT 500');

  if (!data || !data.results || data.results.length === 0) {
    console.log('Aucune donnée retournée.');
    return;
  }

  sheet.clearContents();

  const headers = Object.keys(data.results[0]);
  sheet.getRange(1, 1, 1, headers.length).setValues([headers]);

  const rows = data.results.map(row => headers.map(h => row[h] ?? ''));
  sheet.getRange(2, 1, rows.length, headers.length).setValues(rows);

  console.log(rows.length + ' lignes importées.');
}

Déclencheurs automatiques

Pour automatiser l’import, créez un déclencheur temporel depuis l’interface Apps Script (Déclencheurs > Ajouter un déclencheur) ou par code :

function setupHourlyTrigger() {
  // Supprime les déclencheurs existants sur la même fonction
  ScriptApp.getProjectTriggers()
    .filter(t => t.getHandlerFunction() === 'importClientsFromMySQL')
    .forEach(t => ScriptApp.deleteTrigger(t));

  ScriptApp.newTrigger('importClientsFromMySQL')
    .timeBased()
    .everyHours(1)
    .create();
}

Limite critique : Apps Script interrompt tout script qui s’exécute plus de 6 minutes. Sur des volumes importants, découpez les imports par batch et utilisez un champ updated_at pour ne récupérer que les lignes modifiées depuis la dernière exécution.

Méthode 2 : Outils d’automatisation visuelle

Pour les équipes sans ressources techniques, des outils comme n8n ou Make permettent de configurer la synchronisation via une interface graphique, sans écrire de code.

Comparaison des options courantes

Outil	Modèle de prix	Connecteur MySQL	Fréquence minimale	Points d’attention
n8n	Gratuit en self-hosted, payant en cloud	Natif	Temps réel (webhook)	Nécessite un hébergement si self-hosted
Make	Payant, à partir de ~9€/mois	Natif	1 minute	Tarification à l’opération
Zapier	Payant, à partir de ~20€/mois	Via webhooks	15 min (plan de base)	Simple mais coûteux à l’échelle

n8n est l’outil que Basalt Studio déploie régulièrement pour ce type de flux, notamment parce qu’il peut être hébergé sur l’infrastructure du client et qu’il supporte des logiques conditionnelles avancées sans surcoût d’opérations.

Configuration avec n8n : MySQL vers Google Sheets

Le workflow de base comprend trois nœuds :

Cron : déclencheur programmé (toutes les heures, tous les jours, etc.)
MySQL : nœud en mode Execute Query avec la requête SQL filtrée sur updated_at
Google Sheets : nœud en mode Append or Update Row

La requête SQL dans le nœud MySQL ressemble à :

SELECT id, nom, email, statut, date_modification
FROM clients
WHERE date_modification > NOW() - INTERVAL 1 HOUR
ORDER BY date_modification ASC
LIMIT 200

Dans le nœud Google Sheets, mappez chaque champ MySQL vers la colonne correspondante dans la feuille. Si vous utilisez le mode Append or Update Row, définissez le champ id comme clé de correspondance pour éviter les doublons.

Configuration avec Make

Dans Make, créez un nouveau scénario avec :

Un module MySQL > Execute a Query (ou Watch Rows si vous surveillez de nouvelles entrées)
Un module Google Sheets > Add a Row ou Update a Row

La logique de filtre se gère soit dans la requête SQL, soit avec un module Filter entre les deux. Préférez le filtre SQL : c’est plus performant et cela réduit le nombre d’opérations facturées.

Synchronisation bidirectionnelle : écrire dans MySQL depuis Sheets

La mise à jour de MySQL depuis Google Sheets est utile pour des workflows de validation (un RH qui valide un statut dans Sheets, ce qui met à jour la base) mais introduit des risques : modifications simultanées, données mal formatées, erreurs de types.

Avec Apps Script, le déclencheur onEdit détecte les modifications en temps réel :

function onEdit(e) {
  const sheet = e.range.getSheet();
  if (sheet.getName() !== 'Clients') return;

  const row = e.range.getRow();
  if (row < 2) return; // Ignorer l'en-tête

  const values = sheet.getRange(row, 1, 1, 5).getValues()[0];
  const id = values[0];

  if (!id) return; // Ligne sans identifiant, on ignore

  const payload = {
    query: `UPDATE clients SET statut = '${values[3]}' WHERE id = ${id}`
  };

  // Appeler l'API REST
  const config = getConfig();
  UrlFetchApp.fetch(config.apiUrl, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + config.apiKey },
    payload: JSON.stringify(payload),
    muteHttpExceptions: true
  });
}

Quelques précautions indispensables :

Ne mettez à jour que des colonnes spécifiques, jamais avec un UPDATE *
Validez les données côté Apps Script avant d’envoyer la requête (format email, longueur des champs, types numériques)
Ajoutez une colonne de statut dans Sheets pour indiquer si la mise à jour a réussi ou échoué
Définissez MySQL comme source de vérité : en cas de conflit, les données de la base priment

Erreurs fréquentes et comment les éviter

Dans notre travail d’implémentation de flux de données pour des PME, les problèmes reviennent toujours aux mêmes endroits.

Identifiants stockés en clair dans le code : toute personne ayant accès au script voit le mot de passe de la base. Utilisez toujours PropertiesService (Apps Script) ou les variables d’environnement (n8n, Make).

Absence de gestion d’erreur : un script qui plante silencieusement est pire qu’un script qui n’existe pas. Entourez tous les appels réseau d’un bloc try/catch et configurez des alertes email en cas d’échec.

Utilisateur MySQL avec trop de droits : créez un utilisateur dédié avec uniquement SELECT si la synchronisation est en lecture seule. Si vous avez besoin d’écriture, limitez les droits aux tables concernées.

Synchronisation sans clé unique : sans identifiant stable (id), chaque exécution crée des doublons. Assurez-vous que chaque ligne dans Sheets correspond à un enregistrement MySQL identifiable.

Volumes non anticipés : tester avec 50 lignes fonctionne toujours. Tester avec 10 000 lignes révèle les vraies limites (timeout Apps Script, quotas Make, mémoire n8n). Définissez dès le départ la volumétrie cible et testez avec des données représentatives.

Sécurité et conformité RGPD

Si les données synchronisées incluent des noms, emails, numéros de téléphone ou toute autre information personnelle, plusieurs points s’appliquent :

Minimisation : ne synchronisez que les colonnes strictement nécessaires à l’usage dans Sheets
Droits d’accès : restreignez le partage de la feuille aux personnes qui ont un besoin métier réel
Durée de conservation : définissez une politique de nettoyage des données dans Sheets (archivage ou suppression après X mois)
Traçabilité : conservez un log des opérations de synchronisation, notamment si des modifications sont écrites dans MySQL depuis Sheets

Google Sheets n’est pas un environnement conçu pour stocker des données sensibles à long terme. Pour des données hautement confidentielles (données médicales, informations financières détaillées), une solution d’accès en lecture contrôlée via un outil BI dédié est généralement plus appropriée.

Choisir la bonne méthode selon votre situation

Apps Script convient si :

Vous avez un développeur disponible, même occasionnellement
Vos transformations de données sont complexes (calculs, enrichissement, logique métier)
Vous êtes dans un environnement Google Workspace et voulez éviter des outils tiers
Le budget est une contrainte forte

Un outil comme n8n ou Make convient si :

L’équipe qui maintient le workflow est non technique
Vous avez déjà plusieurs systèmes à connecter (pas seulement MySQL et Sheets)
Vous préférez une interface visuelle pour comprendre et modifier les flux
Vous acceptez un coût mensuel en échange d’une maintenance simplifiée

Dans les deux cas, la connexion MySQL-Sheets reste un outil tactique. Elle est utile pour rendre des données accessibles à une équipe, pas pour remplacer une vraie couche de reporting ou un système d’intégration d’entreprise.

La connexion Google Sheets-MySQL est une bonne première étape d’automatisation pour les PME qui veulent réduire les exports manuels et donner accès aux données métier sans former tout le monde au SQL. Elle demande cependant une préparation rigoureuse côté sécurité et une réflexion honnête sur les volumes et la fréquence de synchronisation avant de choisir l’approche technique.

Si vous souhaitez cartographier vos flux de données et identifier les automatisations les plus rentables pour votre activité, vous pouvez réserver un appel stratégie avec l’équipe Basalt — l’occasion d’examiner vos processus concrets et de définir par où commencer.