Synchroniser Google Sheets et Shopify sans perdre les variantes
Synchronisez correctement Google Sheets et Shopify : CSV, applications ou Apps Script avec productSet, limites réelles et script fonctionnel.
Long Nguyen
Développeur fullstack · Ingénieur IA · Chercheur
La réponse courte
Il existe quatre façons de synchroniser Google Sheets et Shopify pour les produits : importer manuellement un fichier CSV, utiliser une application de synchronisation, créer un Google Apps Script qui appelle l’API Admin de Shopify ou recourir à un service externe. Si vous gérez votre catalogue dans un tableur et souhaitez que Shopify le mette à jour automatiquement selon un calendrier, la solution Apps Script avec la mutation productSet est conçue pour ce cas d’usage. Shopify a créé cette mutation pour répliquer les données produit d’une source externe, et sa documentation cite notamment les tableurs.
Le point délicat est que productSet considère les données envoyées comme l’intégralité du produit. Si une variante ne figure pas dans le tableur, Shopify la supprime. L’objectif principal de ce guide est donc de vous aider à exploiter ce comportement plutôt qu’à le subir.
Les quatre méthodes pour synchroniser Google Sheets et Shopify
| Méthode | Fonctionnement | Adaptée à | Limites |
|---|---|---|---|
| Import CSV | Manuellement : télécharger le tableur au format CSV, puis l’importer dans Produits > Importer | Un premier chargement ou une modification groupée occasionnelle | Pas de planification, limite de fichier de 15 Mo et impossibilité d’annuler l’import une fois lancé |
| Application de synchronisation ou plateforme d’automatisation | Une application installée surveille le tableur et transmet les modifications | Les équipes sans développeur qui veulent une solution immédiate | Des frais récurrents qui augmentent généralement avec la taille du catalogue, et uniquement les champs proposés par l’application |
Apps Script + productSet |
Un script associé au tableur, lancé par un déclencheur temporel | Une seule boutique, avec le tableur comme source principale et quelques centaines à quelques milliers de produits | Durée maximale de 6 minutes, quota quotidien des déclencheurs et code à maintenir soi-même |
| Service externe + opérations en masse | Une petite application hébergée sur votre serveur lit le tableur et écrit dans Shopify | Les catalogues importants, plusieurs boutiques ou canaux et la synchronisation bidirectionnelle | Nécessite un hébergement et un développeur |
La suite de cet article détaille les première et troisième méthodes, car ce sont celles par lesquelles commencent la plupart des boutiques. Elle indique ensuite à partir de quel moment la quatrième devient l’option la plus économique.
Pourquoi un import CSV n’est pas une synchronisation produit
Pour les modifications groupées, Shopify recommande d’exporter les produits, de modifier le fichier dans un tableur comme Google Sheets, puis de le réimporter. Cette méthode fonctionne et convient parfaitement à un chargement ponctuel. Elle devient insuffisante lorsque vous devez exécuter la même mise à jour chaque jour, notamment à cause du comportement de l’importateur :
- La mise à jour n’a lieu que si vous cochez une case. Sans l’option Remplacer les produits dont les handles correspondent, les lignes dont le handle existe déjà dans la boutique sont ignorées.
- Une cellule vide est une instruction. Si une colonne non obligatoire figure dans le fichier mais que la cellule est vide, la valeur existante est remplacée par une valeur vide. Si la colonne ne figure pas dans le fichier, la valeur reste inchangée. Une cellule Vendor vidée supprime le fournisseur.
- Modifier une valeur d’option remplace la variante. Changer les valeurs Option1, Option2 ou Option3 supprime l’ID de variante existant et en crée un nouveau, ce qui casse les références qui utilisaient l’ancien ID.
- Il ne peut pas supprimer de produits, ne peut pas être annulé une fois lancé et ne conserve aucun historique d’import.
- Le fichier ne peut pas dépasser 15 Mo.
Une synchronisation, au sens où l’entendent les personnes qui recherchent ce type de solution, doit pouvoir être répétée sans intervention humaine, être sûre à exécuter deux fois et indiquer quelles lignes ont échoué. L’importateur CSV ne fournit aucune de ces trois garanties. Utilisez-le pour initialiser la boutique, puis passez à l’API.
Comment la mutation productSet synchronise un tableur avec Shopify
productSet est une mutation de l’API Admin GraphQL de Shopify. Au lieu d’indiquer modifier ce prix, vous envoyez le produit complet tel qu’il doit exister. Shopify crée, met à jour ou supprime alors ce qui est nécessaire pour obtenir cet état. Le guide de Shopify sur la synchronisation des données produit avec productSet décrit cette mutation comme la solution adaptée lorsque Shopify est la copie secondaire d’un système externe. Deux règles sont déterminantes :
- Les champs ordinaires absents ne sont pas modifiés ; les champs inclus sont écrasés, même par une valeur vide. Omettez
tagset les balises restent en place. Envoyeztags: []et elles sont supprimées. - Les options et les variantes sont entièrement remplacées. La liste envoyée devient la liste existante. L’exemple de Shopify est clair : un produit qui possède 5 variantes et en reçoit 3 se retrouve avec 3 variantes ; les 2 autres sont supprimées.
La règle 2 explique pourquoi le tableur doit être structuré avec soin. C’est aussi ce qui rend la mutation sûre à répéter : envoyer deux fois les mêmes lignes produit le même produit, et non un doublon.
Le tableur n’a pas besoin des identifiants Shopify
La mutation accepte un argument identifier avec trois possibilités : id met à jour un produit existant, tandis que handle et customId permettent un upsert, c’est-à-dire la mise à jour du produit s’il existe ou sa création dans le cas contraire. Faire correspondre les produits grâce au handle permet au même script de gérer les nouveaux produits et ceux qui existent déjà, sans colonne d’ID.
En pratique, le handle devient votre clé de rapprochement. Si quelqu’un modifie un handle dans le tableur ou le handle d’URL dans l’interface d’administration Shopify, l’exécution suivante ne trouve aucune correspondance et crée un second produit. Verrouillez cette colonne. Si les handles doivent réellement changer au fil du temps, utilisez plutôt un identifiant personnalisé.
Mode synchrone ou asynchrone
Par défaut, l’appel est synchrone et renvoie le produit finalisé. Avec synchronous: false, il renvoie un ID d’opération ; vous interrogez ensuite la requête productOperation jusqu’à ce que son statut soit COMPLETE ou FAILED. Shopify recommande le mode asynchrone lorsqu’un produit volumineux dépasse le délai d’attente. Pour les produits courants, l’appel synchrone permet de garder un script plus court. Dans les deux cas, l’application a besoin du scope d’accès write_products, et un produit peut contenir par défaut 2 048 variantes.
Structurez le tableur avec une ligne par variante
Utilisez un onglet nommé Products, avec une ligne par variante et le handle répété sur chaque ligne d’un même produit.
| handle | title | status | option_name | option_value | sku | price |
|---|---|---|---|---|---|---|
| linen-tee | Linen Tee | active | Size | S | TEE-S | 29 |
| linen-tee | Linen Tee | active | Size | M | TEE-M | 29 |
| stone-mug | Stone Mug | draft | MUG-1 | 14.5 |
Ajoutez quatre autres colonnes : vendor, compare_at_price, sync_status et synced_hash. Les deux dernières sont utilisées par le script. Respectez ensuite les règles suivantes :
- Toutes les variantes d’un produit doivent figurer dans cet onglet. Une ligne supprimée correspond à une variante que Shopify supprimera lors de l’exécution suivante. Répartir un même produit sur plusieurs onglets produit le même effet.
- Les champs propres au produit sont lus sur la première ligne de chaque handle. Conservez le même titre, fournisseur et statut pour tout le groupe.
- Pour les produits sans options, laissez les deux colonnes d’option vides. Le script les envoie comme une variante unique nommée Default Title, ce qui est la représentation Shopify d’un produit sans options.
- Retirer un produit du tableur ne le supprime pas de la boutique. Le script n’envoie que les handles qu’il trouve. Définissez
statussur archived pour retirer un produit du catalogue actif.
Pour rester lisible, le script d’exemple gère une seule option par produit. Une deuxième option, comme la couleur en plus de la taille, nécessite une seconde paire de colonnes d’options et une deuxième entrée dans chacun des deux tableaux d’options.
Obtenir un token API Admin en 2026 : le changement du Dev Dashboard
La plupart des tutoriels indiquent encore d’ouvrir Paramètres > Applications et canaux de vente > Développer des applications, puis de copier un token d’accès API Admin. Cette procédure créait ce que Shopify appelle désormais une application personnalisée héritée et, depuis le , il n’est plus possible d’en créer de nouvelles. Les applications héritées créées avant cette date continuent de fonctionner. Pour une nouvelle synchronisation, procédez ainsi :
- Créez une application dans le Shopify Dev Dashboard.
- Dans la version de l’application, sélectionnez le scope
write_products. - Installez l’application sur votre boutique.
- Copiez le Client ID et le Client secret depuis la page Settings de l’application.
- Dans l’éditeur Apps Script, ouvrez Project Settings et ajoutez trois propriétés de script :
SHOPIFY_SHOP(la partie située avant .myshopify.com),SHOPIFY_CLIENT_IDetSHOPIFY_CLIENT_SECRET.
Il n’y a désormais plus de token à copier. Le script échange le client ID et le secret contre un token en envoyant grant_type=client_credentials à /admin/oauth/access_token sur le domaine myshopify.com de votre boutique. Le token expire après 24 heures ; le script ci-dessous en demande donc un nouveau au début de chaque exécution au lieu de le stocker.
Vérifiez deux points avant de poursuivre :
- L’application et la boutique doivent appartenir à la même organisation Shopify. Sinon, la demande de token échoue avec
shop_not_permitted. Si un freelance ou une agence crée la synchronisation, l’application doit être créée dans votre organisation ou utiliser un autre flux d’autorisation. - L’accès en modification au tableur donne accès au script. Toute personne pouvant modifier le tableur peut ouvrir le projet Apps Script associé. Limitez la liste des éditeurs et ne placez jamais le secret dans une cellule.
Un Google Apps Script pour synchroniser les produits avec Shopify
Dans le tableur, ouvrez Extensions > Apps Script, collez le code et exécutez une fois syncProducts manuellement. Lorsque la colonne sync_status est renseignée, ajoutez un déclencheur temporel pour cette même fonction.
const API_VERSION = '2026-10';
const SHEET_NAME = 'Products';
const MAX_RUN_MS = 4.5 * 60 * 1000;
const MUTATION = [
'mutation sync($input: ProductSetInput!, $identifier: ProductSetIdentifiers) {',
' productSet(input: $input, identifier: $identifier, synchronous: true) {',
' product { id handle }',
' userErrors { code field message }',
' }',
'} '
].join(' ');
function syncProducts() {
const started = Date.now();
const props = PropertiesService.getScriptProperties();
const shop = props.getProperty('SHOPIFY_SHOP');
const token = getToken_(shop, props);
const sheet = SpreadsheetApp.getActive().getSheetByName(SHEET_NAME);
const rows = sheet.getDataRange().getValues();
const head = rows.shift().map(String);
const col = name => head.indexOf(name);
// 1. Group variant rows by product handle.
const groups = {};
rows.forEach((row, i) => {
const handle = String(row[col('handle')]).trim();
if (!handle) return;
(groups[handle] = groups[handle] || []).push({ row: row, line: i + 2 });
});
for (const handle of Object.keys(groups)) {
if (Date.now() - started > MAX_RUN_MS) break; // resume on the next trigger
const items = groups[handle];
const input = buildInput_(handle, items, col);
// 2. Skip products whose rows have not changed since the last good sync.
const hash = hash_(JSON.stringify(input));
if (items[0].row[col('synced_hash')] === hash) continue;
// 3. Send the complete product state, matched by handle.
const body = callShopify_(shop, token, { input: input, identifier: { handle: handle } });
const result = body.data && body.data.productSet;
const errors = result ? result.userErrors : [{ message: JSON.stringify(body.errors) }];
const ok = errors.length === 0;
const status = ok
? 'OK ' + new Date().toISOString()
: 'ERROR ' + errors.map(e => e.message).join(' | ');
// 4. Write the outcome next to every row of that product.
items.forEach(item => {
sheet.getRange(item.line, col('sync_status') + 1).setValue(status);
if (ok) sheet.getRange(item.line, col('synced_hash') + 1).setValue(hash);
});
}
}
function buildInput_(handle, items, col) {
const first = items[0].row;
const optionName = String(first[col('option_name')]).trim() || 'Title';
const valueOf = row => String(row[col('option_value')]).trim() || 'Default Title';
const orNull = value => (value === '' ? null : value);
return {
handle: handle,
title: String(first[col('title')]),
vendor: String(first[col('vendor')]),
status: String(first[col('status')]).toUpperCase(),
productOptions: [{
name: optionName,
values: items.map(item => ({ name: valueOf(item.row) }))
}],
// Every variant of the product must be listed here.
// A variant missing from this array is deleted in Shopify.
variants: items.map(item => ({
optionValues: [{ optionName: optionName, name: valueOf(item.row) }],
sku: String(item.row[col('sku')]),
price: item.row[col('price')],
compareAtPrice: orNull(item.row[col('compare_at_price')])
}))
};
}
function getToken_(shop, props) {
const url = 'https://' + shop + '.myshopify.com/admin/oauth/access_token';
const res = UrlFetchApp.fetch(url, {
method: 'post',
payload: {
grant_type: 'client_credentials',
client_id: props.getProperty('SHOPIFY_CLIENT_ID'),
client_secret: props.getProperty('SHOPIFY_CLIENT_SECRET')
}
});
return JSON.parse(res.getContentText()).access_token;
}
function callShopify_(shop, token, variables) {
const url = 'https://' + shop + '.myshopify.com/admin/api/' + API_VERSION + '/graphql.json';
let body;
for (let attempt = 0; attempt < 3; attempt++) {
const res = UrlFetchApp.fetch(url, {
method: 'post',
contentType: 'application/json',
headers: { 'X-Shopify-Access-Token': token },
payload: JSON.stringify({ query: MUTATION, variables: variables }),
muteHttpExceptions: true
});
body = JSON.parse(res.getContentText());
if (!body.errors) break;
Utilities.sleep(1000); // one-second backoff, then retry
}
const cost = body.extensions && body.extensions.cost;
if (cost && cost.throttleStatus.currentlyAvailable < 200) Utilities.sleep(1000);
return body;
}
function hash_(text) {
const bytes = Utilities.computeDigest(Utilities.DigestAlgorithm.MD5, text);
return 'h' + bytes.map(b => ((b + 256) % 256).toString(16).padStart(2, '0')).join('');
}
Voici ce qu’il fait, dans l’ordre :
- Regroupe les lignes par handle et construit le produit complet afin d’envoyer ensemble toutes les variantes du tableur.
- Ignore les produits inchangés. Il calcule le hachage des données à envoyer et le compare à
synced_hash. Seuls les produits dont les lignes ont changé utilisent un appel API. Effacez la cellule pour forcer un nouvel envoi. - S’arrête au bout de 4,5 minutes. Comme les produits déjà traités sont ignorés lors de l’exécution suivante, le prochain déclencheur reprend là où celui-ci s’est arrêté. Aucun curseur n’est nécessaire.
- Signale le résultat sur chaque ligne. Shopify renvoie les problèmes de validation dans
userErrors, et le message apparaît à côté des lignes concernées. - Ralentit les tentatives si nécessaire. Le script attend une seconde et réessaie lorsque Shopify renvoie une erreur, puis se met en pause lorsque le budget de limitation restant dans la réponse devient faible.
Testez-le sur une boutique de développement avant de l’utiliser en production. Vérifiez-y trois cas : un nouveau produit, une modification de prix et la suppression d’une ligne de variante. La version de l’API est volontairement définie en haut du fichier. Shopify publie de nouvelles versions chaque trimestre : faites-la évoluer délibérément au lieu de la laisser dériver.
Les limites qui déterminent si Apps Script suffit
| Limite | Valeur | Définie par |
|---|---|---|
| Durée d’exécution du script | 6 minutes | |
| Durée totale quotidienne des déclencheurs | 90 minutes (compte grand public), 6 heures (Workspace) | |
| Appels URL Fetch par jour | 20 000 (compte grand public), 100 000 (Workspace) | |
| Débit de l’API Admin GraphQL | 100 points par seconde (forfaits standard), 200 (Advanced), 1 000 (Plus) | Shopify |
| Coût d’une mutation | 10 points par défaut | Shopify |
| Variantes par produit | 2 048 par défaut | Shopify |
| Nouvelles variantes par jour à partir de 500 000 dans une boutique | 10 000 (ne s’applique pas à Plus) | Shopify |
| Durée de validité du token Client Credentials | 24 heures | Shopify |
Les données concernant Google proviennent de la référence des quotas Apps Script. Elles s’appliquent par utilisateur et sont réinitialisées 24 heures après la première requête.
Gardez à l’esprit que le script effectue un appel à la fois : les limites de Google deviennent contraignantes bien avant celles de Shopify. Celle qui surprend le plus est la durée quotidienne des déclencheurs. Un déclencheur horaire qui utilise les 6 minutes disponibles consomme 24 × 6 = 144 minutes par jour, soit plus que les 90 minutes autorisées par un compte Google gratuit. Cette fréquence n’est viable que si la plupart des exécutions sont rapides. C’est précisément l’intérêt de la vérification par hachage : si seules quelques dizaines de produits ont changé depuis la dernière exécution, le script effectue quelques dizaines d’appels et se termine rapidement.
La première synchronisation complète constitue une exception, puisque chaque produit est nouveau. Prévoyez plusieurs exécutions et surveillez le remplissage progressif de sync_status.
Lorsque les modifications quotidiennes elles-mêmes ne tiennent plus dans ces limites, le projet dépasse le cadre d’un script de tableur et devient une petite application personnalisée. C’est le type de projet d’intégration avec l’API Shopify que développe Netalith : la même logique productSet, exécutée sur un serveur avec une file d’attente, des journaux et des alertes.
Faut-il gérer l’inventaire et la synchronisation bidirectionnelle via le tableur ?
Techniquement, oui. productSet accepte inventoryQuantities pour chaque variante, avec un ID d’emplacement et une quantité. La vraie question est de savoir si le tableur connaît réellement cette quantité.
Ce champ attend une quantité absolue, et non un ajustement. Un tableur mis à jour ce matin ne connaît pas les commandes passées depuis : transmettre sa valeur peut donc remettre en vente un stock déjà vendu. Déterminez le responsable de chaque champ avant d’écrire du code :
| Champ | Responsable recommandé | Pourquoi |
|---|---|---|
| Titre, fournisseur, statut | Tableur | Ces champs changent rarement et uniquement lorsqu’une personne le décide |
| Prix, prix avant réduction | Tableur | La tarification est généralement planifiée dans un tableur |
| Quantité en stock | Shopify ou le système qui réceptionne et expédie les stocks | Elle évolue à chaque commande, sans intervention sur le tableur |
| Descriptions, images, champs SEO | Shopify | Ils sont plus faciles à modifier et à prévisualiser dans l’interface d’administration ; omettez-les de l’entrée pour les laisser inchangés |
La synchronisation bidirectionnelle est un projet différent. Dès que les deux systèmes peuvent modifier le même champ, vous devez définir lequel est prioritaire, prévoir un moyen de détecter les modifications faites dans Shopify et empêcher les deux systèmes de se renvoyer indéfiniment les mêmes changements. Si l’équipe a seulement besoin de voir les valeurs actuelles de Shopify, un onglet séparé en lecture seule, actualisé depuis Shopify, répond au besoin sans nécessiter de gestion des conflits.
Quand sortir la synchronisation du tableur
Le script présenté constitue une solution permanente raisonnable pour une seule boutique avec un catalogue de taille modeste. Voici les signes qu’il ne suffit plus :
- Les exécutions atteignent régulièrement la limite de durée, même si seuls les produits modifiés sont envoyés.
- Une deuxième boutique ou une annonce sur une marketplace doit utiliser le même tableur.
- Vous devez faire remonter dans le tableur les modifications effectuées dans Shopify.
- Une synchronisation échouée doit prévenir quelqu’un, au lieu d’attendre dans une colonne qu’une personne la consulte.
- Davantage de personnes doivent modifier le tableur que vous ne souhaiteriez autoriser à accéder aux identifiants de la boutique.
L’étape suivante consiste à conserver le tableur comme espace de travail et à déplacer le moteur sur un serveur. La même mutation peut alors être exécutée dans les opérations en masse de Shopify, qui ne sont pas soumises au plafond de coût ni aux limites de débit applicables aux requêtes individuelles.
Si vous ne savez pas de quel côté se situe votre catalogue, demandez un devis gratuit à Netalith en indiquant les caractéristiques du tableur : nombre de produits, nombre de variantes, fréquence des changements et personnes qui le modifient. Ces informations suffisent pour déterminer si un script tiendra la charge ou si une petite application sera plus économique sur un an.
FAQ
Questions fréquentes
Puis-je synchroniser Google Sheets avec Shopify sans application payante ?
Oui, de deux façons. Vous pouvez télécharger le tableur au format CSV et l’importer dans la section Produits de l’interface d’administration Shopify, mais vous devrez effectuer cette opération manuellement à chaque fois. Vous pouvez aussi associer un Google Apps Script au tableur afin qu’il appelle l’API Admin GraphQL de Shopify via un déclencheur temporel. Cette deuxième solution nécessite de créer vous-même une application dans le Shopify Dev Dashboard, afin que le script dispose des identifiants API.
Une synchronisation de produits entre Google Sheets et Shopify peut-elle supprimer mes produits ou mes variantes ?
Elle peut supprimer des variantes. La mutation productSet considère les variantes envoyées comme la liste complète : une ligne de variante supprimée du tableur entraîne donc la suppression de cette variante du produit lors de l’exécution suivante. Les produits entiers fonctionnent différemment : le script n’envoie que les handles trouvés dans le tableur. Un produit supprimé du tableur reste donc dans la boutique jusqu’à ce que vous l’archiviez.
Ai-je besoin des identifiants des produits Shopify dans mon tableur ?
Non. productSet accepte un identifiant et la correspondance sur le handle fonctionne comme un upsert : Shopify met à jour le produit si ce handle existe et le crée dans le cas contraire. En contrepartie, le handle devient la clé de rapprochement. Si vous le modifiez dans le tableur ou dans l’interface d’administration Shopify, un second produit est créé au lieu de renommer le premier.
À quelle fréquence un Google Apps Script peut-il lancer la synchronisation ?
Aussi souvent que les quotas le permettent. Chaque exécution est limitée à 6 minutes, et la durée totale des exécutions déclenchées est plafonnée à 90 minutes par jour sur un compte Google grand public et à 6 heures sur Google Workspace. Un déclencheur horaire est réaliste uniquement si la plupart des exécutions sont courtes. C’est pourquoi le script doit ignorer les produits qui n’ont pas changé.
Pourquoi ne trouve-t-on plus le token d’accès API Admin mentionné dans les anciens tutoriels ?
Ces tutoriels décrivent les applications personnalisées héritées créées dans l’interface d’administration Shopify. Depuis le 1er janvier 2026, il n’est plus possible de créer de nouvelles applications héritées. Les nouvelles applications sont créées dans le Dev Dashboard, qui fournit un client ID et un client secret à la place d’un token. Votre script les échange contre un token d’accès grâce au flux client credentials, et ce token expire après 24 heures.
Dois-je synchroniser les quantités d’inventaire de Google Sheets vers Shopify ?
Uniquement si le tableur est réellement la source principale du stock et qu’il est mis à jour automatiquement. productSet utilise une quantité absolue par emplacement : un nombre saisi ce matin écrase donc la quantité que Shopify a diminuée à la suite des commandes passées depuis. Pour la plupart des boutiques, il est plus prudent de laisser au tableur la gestion des prix, titres et statuts, et de confier le stock à Shopify ou au système qui le réceptionne et l’expédie.