Gérer les contacts après un événement, une conférence ou même une simple collecte d’informations peut vite devenir un casse-tête. Entre la saisie manuelle, les risques d’erreurs et le temps perdu, on rêve tous d’une solution plus simple. Et si je vous disais que cette solution existe et qu’elle est à portée de clic grâce à Google Apps Script ?
Dans cet article, je vous présente un script que j’ai développé (et récemment mis à jour !) qui va révolutionner votre gestion de contacts : il ajoute automatiquement les informations soumises via un Google Form directement dans vos Google Contacts. Fini la corvée, bonjour l’efficacité !
Pourquoi automatiser l’ajout de contacts ? Les avantages concrets.
Imaginez : vous organisez un atelier et collectez les inscriptions via un Google Form. Au lieu de copier-coller chaque nom, prénom, et e-mail dans Google Contacts, le script s’en charge pour vous dès que quelqu’un soumet le formulaire.
Les bénéfices sont multiples :
- Gain de temps considérable : Plus de saisie manuelle fastidieuse. Consacrez ce temps à des tâches à plus forte valeur ajoutée.
- Réduction des erreurs : L’automatisation limite les fautes de frappe ou les oublis lors du transfert d’informations.
- Centralisation immédiate : Vos contacts sont instantanément disponibles dans Google Contacts, prêts à être utilisés pour vos campagnes d’e-mailing, invitations futures, etc.
- Professionnalisme : Une gestion de contacts efficace et rapide renforce votre image professionnelle.
- Idéal pour tous types d’événements : Que ce soit pour des conférences, des webinaires, des inscriptions à une newsletter, des salons professionnels ou des ateliers, ce script s’adapte à vos besoins.
Comment ça marche sous le capot ?
Ce script Google Apps Script agit comme un pont intelligent entre votre Google Form (ou la feuille Google Sheets qui lui est liée) et votre application Google Contacts. Voici les grandes étapes de son fonctionnement :
- Déclenchement automatique : Dès qu’une nouvelle réponse est soumise à votre formulaire, le script se met en action.
- Extraction des données : Il identifie et récupère les informations pertinentes que vous avez définies (prénom, nom, e-mail, téléphone, entreprise, poste, etc.) en se basant sur les titres de vos questions de formulaire.
- Migration vers l’API People : Initialement basé sur l’ancienne API ContactsApp, le script a été mis à jour pour utiliser la nouvelle API Google People. C’est une évolution importante car l’ancienne API est obsolète. L’API People est plus moderne et robuste pour une gestion programmatique des contacts.
- Vérification des doublons : Avant de créer un nouveau contact, le script vérifie (via l’API People) si un contact avec la même adresse e-mail existe déjà. Si c’est le cas, il évite de créer un doublon (et pourrait même, avec une adaptation, mettre à jour le contact existant).
- Création du contact : Si aucun doublon n’est trouvé, un nouveau contact est créé dans Google Contacts avec toutes les informations recueillies.
- Ajout à un Groupe (pptionnel mais pratique !) : Vous pouvez configurer le script pour qu’il ajoute automatiquement ces nouveaux contacts à un libellé (groupe) spécifique dans Google Contacts (par exemple, « Participants Webinaire Mai 2025 »). Si le libellé n’existe pas, il est préférable de le créer manuellement dans Google Contacts au préalable et de fournir son identifiant au script.
Prêt à l’implémenter ? Voici les grandes lignes !
Intégrer ce script à votre workflow est assez simple, même si vous n’êtes pas un développeur chevronné. Voici les étapes clés (le script complet avec les instructions détaillées sera fourni séparément ou dans un prochain article technique !) :
- Accéder à l’éditeur de script : Depuis votre Google Form ou la feuille de calcul associée.
- Activer le service « People API » : C’est une étape cruciale. Dans l’éditeur, vous devez ajouter le service avancé « Google People API » à votre projet.
- Copier-Coller le code : Vous insérez le code du script dans l’éditeur.
- Configurer les variables : Vous devrez indiquer au script quels titres de questions de votre formulaire correspondent au prénom, nom, e-mail, etc. C’est une étape de personnalisation simple mais essentielle. Vous pourrez aussi spécifier l’identifiant du groupe de contacts si vous utilisez cette fonctionnalité.
- Mettre en place le déclencheur : Il faut indiquer à Google que le script doit s’exécuter « sur soumission de formulaire ». Cela se fait en quelques clics via l’interface des déclencheurs d’Apps Script.
- Autoriser le script : La première fois, Google vous demandera d’autoriser le script à accéder à vos données (formulaires et contacts). C’est une procédure standard et sécurisée.
- Tester ! Soumettez une réponse test à votre formulaire et regardez la magie opérer dans Google Contacts !
Le code
/**
* @OnlyCurrentDoc
*
*/
// --- CONFIGURATION ---
// IMPORTANT : Ajustez ces titres de colonnes pour qu'ils correspondent EXACTEMENT aux titres de vos questions Google Form
const PRENOM_COLONNE_TITRE = "Prénom";
const NOM_COLONNE_TITRE = "Nom";
const EMAIL_COLONNE_TITRE = "Adresse e-mail"; // Ou la question e-mail de votre formulaire
const TELEPHONE_COLONNE_TITRE = "Numéro de téléphone"; // Optionnel
const ENTREPRISE_COLONNE_TITRE = "Entreprise"; // Optionnel
const POSTE_COLONNE_TITRE = "Poste"; // Optionnel
// Optionnel : Spécifiez un NOM DE RESSOURCE de groupe de contacts (étiquette).
// Pour obtenir le nom de la ressource :
// 1. Allez sur https://contacts.google.com/
// 2. Créez ou sélectionnez le libellé (groupe) souhaité.
// 3. L'ID du libellé sera dans l'URL (par exemple, .../label/c1234567890)
// 4. Le nom de la ressource sera "contactGroups/c1234567890"
// Si vide (''), les contacts ne seront pas ajoutés à un groupe spécifique.
// Si le groupe n'existe pas, le script tentera de le créer (voir la note ci-dessous).
const NOM_RESSOURCE_GROUPE_CONTACT = ""; // Exemple: "contactGroups/votreressourceid"
// Note: La création de groupe via l'API People est plus complexe qu'avec l'ancien ContactsApp.
// Il est recommandé de créer le groupe/libellé manuellement dans Google Contacts
// et de coller son nom de ressource ici.
// --- LOGIQUE DU SCRIPT ---
/**
* Fonction à déclencher lors de la soumission du formulaire.
* @param {Object} e L'objet événement.
*/
function onFormSubmit(e) {
try {
const formResponse = e.namedValues;
// --- 1. Obtenir les données du formulaire ---
if (!formResponse[EMAIL_COLONNE_TITRE] || formResponse[EMAIL_COLONNE_TITRE][0] === "") {
console.warn("Réponse ignorée : l'adresse e-mail est manquante.");
return;
}
const prenom = formResponse[PRENOM_COLONNE_TITRE] ? formResponse[PRENOM_COLONNE_TITRE][0] : "";
const nom = formResponse[NOM_COLONNE_TITRE] ? formResponse[NOM_COLONNE_TITRE][0] : "";
const email = formResponse[EMAIL_COLONNE_TITRE][0];
const telephone = formResponse[TELEPHONE_COLONNE_TITRE] ? formResponse[TELEPHONE_COLONNE_TITRE][0] : "";
const entreprise = formResponse[ENTREPRISE_COLONNE_TITRE] ? formResponse[ENTREPRISE_COLONNE_TITRE][0] : "";
const poste = formResponse[POSTE_COLONNE_TITRE] ? formResponse[POSTE_COLONNE_TITRE][0] : "";
// --- 2. Vérifier l'existence d'un contact par e-mail avec l'API People ---
// La recherche directe par e-mail pour vérifier les doublons avant la création
// est moins simple avec People API qu'avec ContactsApp.
// People API.people.searchContacts est plus général.
// Une approche est de créer le contact puis de gérer les doublons si Google les lie,
// ou de chercher par e-mail et de ne pas créer si trouvé.
// Pour la simplicité, nous allons vérifier si un contact avec cet e-mail existe.
// Attention: cette recherche peut retourner plusieurs résultats si l'e-mail est présent dans plusieurs champs.
let contactExistant = null;
try {
const searchResults = People.People.searchContacts({
query: email,
readMask: "emailAddresses,names" // Demander les champs nécessaires pour la vérification
});
if (searchResults.results && searchResults.results.length > 0) {
for (let i = 0; i < searchResults.results.length; i++) {
const person = searchResults.results[i].person;
if (person.emailAddresses) {
for (let j = 0; j < person.emailAddresses.length; j++) {
if (person.emailAddresses[j].value === email) {
contactExistant = person;
console.log(`Un contact avec l'e-mail ${email} existe déjà : ${person.resourceName}. Ignoré.`);
// Optionnellement, mettre à jour le contact existant ici.
// Par exemple : updateExistingContact(person.resourceName, prenom, nom, telephone, entreprise, poste);
return;
}
}
}
}
}
} catch (searchError) {
console.warn(`Avertissement lors de la recherche de contact existant : ${searchError.toString()}. Tentative de création quand même.`);
// Ce bloc catch est pour les cas où la recherche elle-même échoue, mais on veut quand même tenter de créer le contact.
}
// --- 3. Créer un nouveau contact avec l'API People ---
console.log(`Création d'un nouveau contact pour : ${email}`);
const nouveauContactPayload = {
names: [{ givenName: prenom, familyName: nom }],
emailAddresses: [{ value: email, type: 'home' }], // 'home', 'work', etc.
phoneNumbers: telephone ? [{ value: telephone, type: 'mobile' }] : [], // 'mobile', 'work', etc.
organizations: entreprise ? [{ name: entreprise, title: poste }] : []
};
let personneCreee;
try {
personneCreee = People.People.createContact(nouveauContactPayload);
console.log(`Contact ${email} créé avec succès. Nom de ressource : ${personneCreee.resourceName}`);
} catch (createError) {
console.error(`Erreur lors de la création du contact ${email}: ${createError.toString()}`);
if (createError.details && createError.details.errors) {
createError.details.errors.forEach(err => console.error(`Détail erreur API: ${err.message}`));
}
return; // Arrêter si la création échoue
}
// --- 4. (Optionnel) Ajouter au groupe de contacts (Libellé) ---
if (NOM_RESSOURCE_GROUPE_CONTACT && NOM_RESSOURCE_GROUPE_CONTACT !== "" && personneCreee && personneCreee.resourceName) {
try {
// Vérifier si le groupe existe réellement (People.contactGroups.get peut être utilisé ici)
// Pour simplifier, on suppose que NOM_RESSOURCE_GROUPE_CONTACT est valide.
// La création de groupe via l'API est plus complexe, il est préférable de créer le libellé manuellement.
People.ContactGroups.Members.modify(NOM_RESSOURCE_GROUPE_CONTACT, {
resourceNamesToAdd: [personneCreee.resourceName]
});
console.log(`Contact ${personneCreee.resourceName} ajouté au groupe/libellé "${NOM_RESSOURCE_GROUPE_CONTACT}".`);
} catch (groupError) {
console.error(`Erreur lors de l'ajout du contact au groupe ${NOM_RESSOURCE_GROUPE_CONTACT}: ${groupError.toString()}`);
if (groupError.message.includes("REQUEST_INVALID_ARGUMENT") || groupError.message.includes("NOT_FOUND")) {
console.warn(`Le groupe/libellé avec le nom de ressource "${NOM_RESSOURCE_GROUPE_CONTACT}" n'a pas été trouvé ou est invalide. Veuillez le créer dans Google Contacts et mettre à jour NOM_RESSOURCE_GROUPE_CONTACT dans le script.`);
}
}
}
} catch (error) {
console.error(`Erreur lors du traitement de la soumission du formulaire : ${error.toString()}\nStack: ${error.stack}`);
// Optionnel : Envoyer une notification par e-mail concernant l'erreur
// MailApp.sendEmail("votre-email@example.com", "Erreur script Google Contacts", `Une erreur s'est produite : ${error.toString()}`);
}
}
/**
* Fonction d'aide pour configurer le déclencheur manuellement si nécessaire,
* ou pour tester la fonction onFormSubmit avec des données factices.
*/
function setupTrigger() {
// Supprime tous les déclencheurs existants pour ce script afin d'éviter les doublons en cas de réexécution.
const declencheursActuels = ScriptApp.getProjectTriggers();
for (let i = 0; i < declencheursActuels.length; i++) {
ScriptApp.deleteTrigger(declencheursActuels[i]);
}
// Crée un nouveau déclencheur pour la fonction onFormSubmit pour le formulaire actif.
ScriptApp.newTrigger('onFormSubmit')
.forForm(FormApp.getActiveForm()) // Ou forSpreadsheet(SpreadsheetApp.getActiveSpreadsheet()) si exécuté depuis la feuille
.onFormSubmit()
.create();
console.log("Déclencheur 'onFormSubmit' configuré pour s'exécuter lors de la soumission du formulaire.");
}
/**
* Fonction pour tester la logique de création de contact avec des données d'exemple.
* Vous devrez peut-être ajuster les données factices en fonction de vos constantes de CONFIGURATION.
* Assurez-vous d'avoir activé le service People API.
*/
function testAddContact() {
// Vérifier si le service People est disponible (une simple vérification)
if (typeof People === 'undefined' || typeof People.People === 'undefined') {
console.error("Le service People API n'est pas activé ou n'est pas disponible. Veuillez l'activer dans les services avancés de l'éditeur de script.");
SpreadsheetApp.getUi().alert("Erreur de configuration", "Le service People API n'est pas activé. Veuillez l'activer dans l'éditeur de script sous 'Services +'.", SpreadsheetApp.getUi().ButtonSet.OK);
return;
}
const evenementFactice = {
namedValues: {
[PRENOM_COLONNE_TITRE]: ['Jean TestAPI'],
[NOM_COLONNE_TITRE]: ['Dupont TestAPI'],
// Utilisez une adresse e-mail unique pour chaque test pour éviter les conflits de doublons lors des tests
[EMAIL_COLONNE_TITRE]: [`test.api.utilisateur.${new Date().getTime().toString().slice(-5)}@example.com`],
[TELEPHONE_COLONNE_TITRE]: ['0987654321'],
[ENTREPRISE_COLONNE_TITRE]: ['Test Corp API'],
[POSTE_COLONNE_TITRE]: ['Testeur API']
}
};
onFormSubmit(evenementFactice);
}
// Fonction optionnelle pour mettre à jour un contact existant (à développer si besoin)
/*
function updateExistingContact(resourceName, prenom, nom, telephone, entreprise, poste) {
try {
const contactToUpdate = People.People.get(resourceName, {
personFields: "names,emailAddresses,phoneNumbers,organizations" // Champs que vous voulez potentiellement lire/modifier
});
// Mettez à jour les champs nécessaires. L'API People utilise un ETag pour la concurrence optimiste.
// Il est important de fournir l'ETag du contact que vous mettez à jour.
const updatedPayload = {
resourceName: resourceName,
etag: contactToUpdate.etag, // Important !
names: [{ givenName: prenom, familyName: nom }], // Modifiez ou conservez les existants
// emailAddresses: [{ value: contactToUpdate.emailAddresses[0].value }], // Les e-mails ne devraient généralement pas changer pour une mise à jour
phoneNumbers: telephone ? [{ value: telephone, type: 'mobile' }] : (contactToUpdate.phoneNumbers || []),
organizations: entreprise ? [{ name: entreprise, title: poste }] : (contactToUpdate.organizations || [])
// Ajoutez d'autres champs si nécessaire
};
const updatedPerson = People.People.updateContact(resourceName, updatedPayload, {
updatePersonFields: "names,phoneNumbers,organizations" // Spécifiez les champs que vous modifiez
});
console.log(`Contact ${resourceName} mis à jour avec succès.`);
} catch (updateError) {
console.error(`Erreur lors de la mise à jour du contact ${resourceName}: ${updateError.toString()}`);
}
}
*/
Conclusion
L’automatisation de l’ajout de contacts depuis Google Forms vers Google Contacts via Apps Script est un excellent moyen d’optimiser votre temps et d’assurer une gestion de données propre et efficace. Avec la migration vers la nouvelle API People, ce type de script reste une solution pérenne et puissante.
N’hésitez pas à explorer cette solution pour simplifier la gestion de vos contacts événementiels ou de vos listes de prospects. C’est un petit effort de configuration pour un grand gain de productivité !
Et vous, quelles sont vos astuces pour gérer vos contacts efficacement ? Partagez-les en commentaire !