Script Google Calendar : Comment refuser automatiquement les réunions inutiles

La majorité des professionnels passent entre 30 et 40 % de leur semaine de travail en réunion. Selon une étude publiée par la Harvard Business Review, plus de 70 % de ces réunions sont jugées improductives par les participants eux-mêmes.

Le problème n'est pas le manque de volonté pour dire non, c'est que les outils par défaut ne facilitent pas ce refus. Les invitations arrivent, elles s'accumulent, et sans action proactive, votre agenda se remplit avant que vous ayez eu le temps de planifier votre vrai travail.

Cet article vous explique comment mettre en place un script Google Calendar qui refuse automatiquement les réunions inutiles.

Nous couvrons trois niveaux d'automatisation, du plus accessible au plus avancé : un script Google Apps Script basique basé sur des règles, une version enrichie avec l'API Gemini pour l'analyse sémantique, et une implémentation Python pour les utilisateurs qui souhaitent plus de contrôle local.

Vous pouvez choisir le niveau qui correspond à votre profil technique.

• Niveau 1 : Apps Script basique : aucune configuration externe, fonctionne directement depuis script.google.com, idéal pour les non-développeurs
• Niveau 2 : Apps Script + Gemini AI : nécessite une clé API gratuite, analyse le contexte des invitations et rédige des refus personnalisés
• Niveau 3 : Python local : nécessite Python installé et un projet Google Cloud, adapté aux usages avancés avec logging persistant

Pourquoi les outils natifs de Google ne suffisent pas

Google a investi dans des fonctionnalités de protection du temps de travail.

Le mode "Concentration" (Focus Time) de Google Agenda, renforcé avec l'intégration Gemini en 2025, permet de signaler des plages horaires comme indisponibles et de résumer automatiquement les réunions.

C'est utile, mais c'est une solution passive. En effet, le mode Focus Time informe les autres que vous êtes occupé mais il ne bloque pas les invitations entrantes.

Une invitation envoyée pendant un bloc de concentration atterrit quand même dans votre agenda avec le statut "En attente".

Vous devez donc toujours prendre une décision manuellement pour chaque invitation reçue.

De plus, l'interface native ne permet pas de poser des règles conditionnelles précises. Par exemple, vous ne pouvez pas configurer Google Agenda pour refuser automatiquement toute invitation sans description provenant d'un expéditeur précis, ou décliner les réunions de plus de dix participants sans ordre du jour explicite.

Ce niveau de personnalisation nécessite du code.

Depuis l'introduction du paramètre eventType dans l'API Google Calendar (couvrant les types focusTime, outOfOffice, workingLocation), les filtres natifs sont devenus plus granulaires mais aussi plus imprévisibles.

Des réponses automatiques d'absence configurées dans l'interface peuvent ne pas se déclencher sur des invitations marquées comme "Focus Time" par l'expéditeur. Ce type de comportement inattendu justifie de prendre le contrôle via le script plutôt que de s'en remettre à l'interface.

Les limites du traitement manuel

• Fatigue décisionnelle : chaque invitation génère une micro-décision. Sur vingt invitations par semaine, cela représente une charge mentale réelle qui s'accumule tout au long de la journée.
• Délai de réponse : un créneau non traité rapidement reste bloqué dans l'agenda de l'organisateur, même si vous avez l'intention de refuser. L'automatisation libère le créneau immédiatement.
• Pression sociale : refuser une invitation manuellement demande une justification implicite. Un système automatique envoie un message standardisé que personne n'interprète comme un rejet personnel.
• Incohérence : votre seuil de tolérance pour accepter une réunion varie selon votre état de fatigue, l'heure de la journée, et la semaine. Un script applique les mêmes règles à 9h un lundi et à 17h30 un vendredi.

Comprendre la logique avant d'écrire le code

Il existe deux approches pour automatiser le filtrage des réunions.

La première est l'approche par règles strictes (Rule-Based) : on définit des critères binaires simples, et si la description est vide, on refuse ; si le titre contient certains mots-clés sans description associée, on refuse.

C'est direct, prévisible, et facile à maintenir. La limite est le manque de nuance : un filtre strict ne distingue pas un "Point projet" d'un entretien annuel si les deux arrivent sans description.

La seconde approche intègre un modèle de langage (LLM) pour analyser la sémantique de l'invitation.

L'IA comprend qu'une réunion intitulée "Entretien annuel" sans description est probablement importante, alors qu'une réunion "Quick sync" avec quinze participants et aucun ordre du jour ne l'est probablement pas.

Cette approche réduit significativement les faux positifs mais nécessite une clé API et une configuration supplémentaire.

Dans tous les cas, le principe de la liste blanche (allowlist) est non-négociable.

Avant de déployer tout script de refus automatique, définissez la liste des adresses email ou des domaines qui ne seront jamais touchés par le filtre. Ajoutez également une liste de mots-clés de sécurité : si le titre d'une invitation contient "entretien", "annuel", "salaire", "disciplinaire" ou "direction", le script doit systématiquement ignorer cette invitation, quelle que soit la qualité de sa description. C'est la première chose à configurer, pas la dernière.

Niveau 1 : Le script Apps Script basique

Ce script scanne votre agenda pour les sept prochains jours. Il identifie toutes les invitations en attente de réponse, et si une invitation n'a pas de description ou dure moins de quinze minutes, il la refuse avec un message explicatif.

Les adresses dans la liste blanche sont systématiquement ignorées.

Pour le déployer : rendez-vous sur script.google.com, cliquez sur "Nouveau projet", supprimez le contenu par défaut, et collez le code ci-dessous. Sauvegardez avec Ctrl+S.

function autoDeclineNoAgenda() {
  // --- CONFIGURATION ---
  const MIN_DURATION_MINUTES = 15;
  const REFUSAL_MESSAGE = "Bonjour, je décline automatiquement les réunions sans ordre du jour ou de moins de 15 minutes. Merci de mettre à jour l'invitation avec un objectif clair.";
  const WHITELIST_EMAILS = ["direction@entreprise.com", "rh@entreprise.com"]; // Adresses jamais refusées
  const SAFETY_KEYWORDS = ["entretien", "annuel", "salaire", "bonus", "disciplinaire"];

  // Fenêtre d'analyse : les 7 prochains jours
  const now = new Date();
  const end = new Date();
  end.setDate(now.getDate() + 7);

  const events = CalendarApp.getDefaultCalendar().getEvents(now, end);

  for (let i = 0; i < events.length; i++) {
    const event = events[i];
    const title = event.getTitle();
    const description = event.getDescription();
    const durationMinutes = (event.getEndTime() - event.getStartTime()) / (1000 * 60);
    const creator = event.getCreators()[0];
    const myStatus = event.getMyStatus();

    // On ne traite que les invitations en attente ou marquées "peut-être"
    if (myStatus !== CalendarApp.GuestStatus.INVITED &&
        myStatus !== CalendarApp.GuestStatus.MAYBE) {
      continue;
    }

    // Vérification de la liste blanche
    if (WHITELIST_EMAILS.includes(creator)) {
      console.log(`Ignoré (liste blanche) : ${title}`);
      continue;
    }

    // Vérification des mots-clés de sécurité dans le titre
    const titleLower = title.toLowerCase();
    if (SAFETY_KEYWORDS.some(kw => titleLower.includes(kw))) {
      console.log(`Ignoré (mot-clé de sécurité) : ${title}`);
      continue;
    }

    let shouldDecline = false;

    // Critère 1 : Aucune description (pas d'ordre du jour)
    if (!description || description.trim() === "") {
      shouldDecline = true;
      console.log(`À refuser (sans description) : ${title}`);
    }

    // Critère 2 : Durée inférieure au minimum configuré
    if (durationMinutes < MIN_DURATION_MINUTES) {
      shouldDecline = true;
      console.log(`À refuser (durée : ${durationMinutes} min) : ${title}`);
    }

    if (shouldDecline) {
      try {
        // Décommentez la ligne suivante pour activer le refus réel
        // event.setMyStatus(CalendarApp.GuestStatus.NO);

        // Décommentez pour envoyer un email de refus à l'organisateur
        // MailApp.sendEmail(creator, "Refus automatique : " + title, REFUSAL_MESSAGE);

        console.log(`Refusé : ${title}`);
      } catch (e) {
        console.error(`Erreur lors du refus de "${title}" : ${e.message}`);
      }
    }
  }
}

Une fois le code sauvegardé, configurez un déclencheur : cliquez sur l'icône d'horloge dans le menu de gauche ("Déclencheurs"), puis sur "Ajouter un déclencheur".

Sélectionnez la fonction autoDeclineNoAgenda, choisissez "Déclencheur basé sur le temps", puis "Toutes les heures".

Le script s'exécutera automatiquement en arrière-plan, même si votre navigateur est fermé.

Important : les deux lignes d'action (refus et email) sont commentées par défaut, laissez-les ainsi pendant la première semaine. Consultez les logs d'exécution pour vérifier que le script identifie correctement les réunions à refuser avant d'activer les actions réelles.

Niveau 2 : Connecter Gemini pour une analyse contextuelle

Les règles binaires ont leurs limites.

Un responsable peut envoyer une invitation sans description parce qu'il utilise un outil tiers qui ne transfère pas ce champ. Un filtre strict refuserait cette invitation alors qu'elle mérite une réponse différente.

L'analyse par IA résout ces cas ambigus en lisant le contexte global de l'invitation plutôt qu'en vérifiant la présence ou l'absence d'un champ précis.

Ce niveau nécessite une clé API Gemini, disponible gratuitement sur Google AI Studio pour un usage personnel modéré.

Stockez cette clé dans les Propriétés du script (menu Projet > Paramètres du projet > Propriétés de script) et appelez-la avec PropertiesService.getScriptProperties().getProperty('GEMINI_API_KEY') plutôt que de la coller directement dans le code source.

Ce que l'analyse IA apporte

• Compréhension sémantique : elle distingue "Point projet" (contexte souvent vague) de "Revue de contrat" (contexte à fort enjeu), même sans description explicite.
• Analyse des participants : si plusieurs membres de votre équipe sont déjà présents, l'IA peut identifier que votre présence est redondante et le signaler dans sa justification.
• Réponse contextualisée : au lieu d'un message de refus générique, l'IA peut rédiger une justification adaptée au contenu spécifique de l'invitation.
• Apprentissage des patterns : en analysant les logs sur plusieurs semaines, vous pouvez affiner le prompt pour qu'il reflète précisément vos propres critères de pertinence.

function analyzeAndDeclineWithAI() {
  const GEMINI_API_KEY = PropertiesService.getScriptProperties().getProperty('GEMINI_API_KEY');
  const GEMINI_URL = `https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=${GEMINI_API_KEY}`;
  const WHITELIST_EMAILS = ["direction@entreprise.com", "rh@entreprise.com"];
  const SAFETY_KEYWORDS = ["entretien", "annuel", "salaire", "bonus", "disciplinaire"];

  const now = new Date();
  const end = new Date();
  end.setDate(now.getDate() + 3); // Fenêtre de 3 jours

  const events = CalendarApp.getDefaultCalendar().getEvents(now, end);

  for (let event of events) {
    if (event.getMyStatus() !== CalendarApp.GuestStatus.INVITED) continue;

    const creator = event.getCreators()[0];
    if (WHITELIST_EMAILS.includes(creator)) continue;

    const titleLower = event.getTitle().toLowerCase();
    if (SAFETY_KEYWORDS.some(kw => titleLower.includes(kw))) continue;

    const eventDetails = {
      title: event.getTitle(),
      description: event.getDescription() || "(aucune description)",
      organizer: creator,
      durationMinutes: (event.getEndTime() - event.getStartTime()) / (1000 * 60),
      attendeesCount: event.getGuestList().length
    };

    const prompt = `
      Tu es un assistant de gestion d'agenda professionnel. Analyse cette invitation de réunion
      et détermine si elle mérite un refus automatique selon les critères suivants.

      Titre : "${eventDetails.title}"
      Description : "${eventDetails.description}"
      Organisateur : "${eventDetails.organizer}"
      Durée : ${eventDetails.durationMinutes} minutes
      Nombre de participants : ${eventDetails.attendeesCount}

      Critères de refus :
      1. Description absente ou trop vague pour identifier l'objectif de la réunion.
      2. Réunion de masse (plus de 10 participants) sans rôle clairement défini pour l'invité.
      3. Titre générique ("Point", "Sync", "Update", "Catch-up") sans description explicative.

      Réponds UNIQUEMENT avec un objet JSON valide, sans texte autour :
      {"decline": boolean, "reason": "explication courte en français"}
    `;

    const payload = {
      "contents": [{ "parts": [{ "text": prompt }] }]
    };

    try {
      const response = UrlFetchApp.fetch(GEMINI_URL, {
        'method': 'post',
        'contentType': 'application/json',
        'payload': JSON.stringify(payload)
      });

      const jsonResponse = JSON.parse(response.getContentText());
      const aiText = jsonResponse.candidates[0].content.parts[0].text;

      // Nettoyage des balises markdown que certains modèles ajoutent autour du JSON
      const cleanJson = aiText.replace(/```json/g, '').replace(/```/g, '').trim();
      const decision = JSON.parse(cleanJson);

      console.log(`Analyse "${eventDetails.title}" :`, decision);

      if (decision.decline === true) {
        // Décommentez pour activer le refus réel
        // event.setMyStatus(CalendarApp.GuestStatus.NO);
        console.log(`>>> Refus suggéré : ${decision.reason}`);
      }

    } catch (e) {
      console.error(`Erreur (API Gemini ou parsing JSON) pour "${eventDetails.title}" :`, e);
    }
  }
}

Déployer sans risque : le mode observation

Quelle que soit l'approche choisie, la méthode de déploiement recommandée est identique.

La première semaine, toutes les lignes d'action restent commentées. Le script tourne, analyse, et journalise ses décisions dans la console d'exécution (accessible via le menu "Exécutions" dans l'interface Apps Script), mais ne modifie rien dans votre agenda. Vous observez donc ce qu'il aurait refusé.

À la fin de la semaine, parcourez les logs et évaluez la qualité des décisions.

Si vous constatez des faux positifs, comme par exemple des réunions importantes que le script aurait refusées à tort, ajustez les règles ou enrichissez la liste blanche avant de passer à l'étape suivante.

Ce n'est qu'une fois satisfait du taux de précision que vous décommentez les lignes d'action et activez le refus réel.

Ne déployez jamais une version avec refus actif en fin de semaine ou avant un jour férié.

Si une configuration produit des résultats inattendus, vous devez être disponible pour la corriger rapidement. La règle d'or en déploiement de scripts automatisés : toujours avoir une fenêtre de supervision active immédiatement après l'activation.

Niveau 3 : Implémentation Python pour les utilisateurs avancés

Google Apps Script est suffisant pour la majorité des cas.

Python devient pertinent lorsque vous avez besoin d'une persistance des données (les logs Apps Script disparaissent après quelques jours), d'une intégration avec des systèmes externes (base de données, Slack via webhook, système de ticketing), ou d'un volume d'événements supérieur aux quotas d'exécution d'Apps Script (6 minutes par jour pour les comptes gratuits).

Ce script nécessite la création d'un projet dans la Google Cloud Console, l'activation de l'API Google Calendar, et le téléchargement du fichier credentials.json.

Installez les dépendances avec :

pip install google-auth google-auth-oauthlib google-api-python-client

import datetime
import os.path
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build

# Scope requis pour lire et modifier le calendrier
SCOPES = ['https://www.googleapis.com/auth/calendar']

WHITELIST_EMAILS = ["direction@entreprise.com", "rh@entreprise.com"]
SAFETY_KEYWORDS = ["entretien", "annuel", "salaire", "disciplinaire", "direction", "bonus"]


def get_my_response_status(event):
    """
    Retourne le statut de réponse de l'utilisateur authentifié.
    Dans l'API Google Calendar v3, ce statut se trouve dans la liste
    des participants (attendees), sur l'entrée où 'self' est True.
    """
    for attendee in event.get('attendees', []):
        if attendee.get('self'):
            return attendee.get('responseStatus', 'needsAction')
    # Si aucune liste d'attendees (l'utilisateur est l'organisateur), on conserve
    return 'accepted'


def main():
    creds = None

    if os.path.exists('token.json'):
        creds = Credentials.from_authorized_user_file('token.json', SCOPES)

    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file('credentials.json', SCOPES)
            creds = flow.run_local_server(port=0)
        with open('token.json', 'w') as token:
            token.write(creds.to_json())

    service = build('calendar', 'v3', credentials=creds)

    now = datetime.datetime.utcnow().isoformat() + 'Z'
    week_later = (datetime.datetime.utcnow() + datetime.timedelta(days=7)).isoformat() + 'Z'

    print('Analyse des événements en attente...')
    events_result = service.events().list(
        calendarId='primary',
        timeMin=now,
        timeMax=week_later,
        maxResults=50,
        singleEvents=True,
        orderBy='startTime'
    ).execute()
    events = events_result.get('items', [])

    if not events:
        print('Aucun événement trouvé dans cette fenêtre.')
        return

    # Récupération de l'adresse email de l'utilisateur authentifié
    profile = service.calendarList().get(calendarId='primary').execute()
    user_email = profile.get('id', '')

    for event in events:
        title = event.get('summary', '(sans titre)')
        description = event.get('description', '').strip()
        organizer = event.get('organizer', {}).get('email', '')
        my_status = get_my_response_status(event)

        # On ne traite que les invitations en attente de réponse
        if my_status != 'needsAction':
            continue

        print(f"\nAnalyse : {title}")

        if organizer in WHITELIST_EMAILS:
            print(f"  -> Conservé (liste blanche)")
            continue

        title_lower = title.lower()
        if any(keyword in title_lower for keyword in SAFETY_KEYWORDS):
            print(f"  -> Conservé (mot-clé de sécurité détecté)")
            continue

        should_decline = False
        reason = ""

        if not description:
            should_decline = True
            reason = "Pas d'ordre du jour"

        generic_titles = ["point", "sync", "catch up", "catch-up", "update", "quick"]
        if any(word in title_lower for word in generic_titles) and not description:
            should_decline = True
            reason = "Titre générique sans contenu"

        if should_decline:
            print(f"  -> REFUS AUTOMATIQUE : {reason}")
            try:
                # sendUpdates='none' évite d'envoyer un email à tous les participants
                service.events().patch(
                    calendarId='primary',
                    eventId=event['id'],
                    sendUpdates='none',
                    body={
                        'attendees': [{
                            'email': user_email,
                            'responseStatus': 'declined'
                        }]
                    }
                ).execute()
                print(f"  -> Statut mis à jour : 'declined'")
            except Exception as e:
                print(f"  -> Erreur lors du refus : {e}")
        else:
            print(f"  -> Conservé.")


if __name__ == '__main__':
    main()

Pour exécuter ce script automatiquement sur Linux ou macOS, ajoutez une tâche CRON avec crontab -e :

# Exécution toutes les heures entre 8h et 19h en jours ouvrés
0 8-19 * * 1-5 /usr/bin/python3 /chemin/vers/votre/script.py >> /var/log/calendar_bot.log 2>&1

Sur Windows, utilisez le Planificateur de tâches (Task Scheduler) pour configurer l'exécution périodique.

L'avantage du log local (/var/log/calendar_bot.log) est sa persistance illimitée : vous pouvez analyser des semaines de données pour comprendre les patterns d'invitations que vous recevez, identifier les organisateurs qui n'incluent jamais d'ordre du jour, ou produire un rapport concret sur le volume de temps récupéré.

Les alternatives sans code

Si vous préférez une solution prête à l'emploi, trois outils dominent ce marché en 2026.

Ils utilisent les mêmes API que les scripts présentés ici, mais proposent une interface graphique et un abonnement mensuel.

Reclaim.ai est la solution la plus adaptée aux utilisateurs individuels. Sa fonctionnalité "Smart Meetings" négocie automatiquement les créneaux en fonction de vos priorités déclarées et protège vos blocs de travail profond. L'outil repositionne les réunions peu prioritaires plutôt que de les refuser directement, ce qui est socialement plus neutre dans les environnements corporate.

Clockwise est orienté gestion d'équipe. Il optimise les plannings de l'ensemble d'un groupe pour créer des plages de travail ininterrompues communes. Son efficacité dépend fortement du taux d'adoption au sein de l'équipe, il fonctionne bien si tout le monde joue le jeu, mais son utilité est limitée en usage strictement individuel.

Motion utilise l'IA pour planifier chaque tâche et réunion à la minute, en réorganisant dynamiquement votre journée quand de nouveaux éléments arrivent. C'est l'outil le plus interventionniste des trois, utile si vous voulez une gestion totalement automatisée, mais contraignant si vous préférez conserver le contrôle sur votre planning.

Ces trois outils sont des interfaces construites sur les mêmes API Google que nous venons d'utiliser directement. La différence est le prix mensuel et l'absence de contrôle sur vos données.

Sur le même sujet: Comment obtenir des identifiants Oauth 2 pour l'API gmail

Choisir le bon niveau d'automatisation

La mise en place d'un script Google Calendar se construit par étapes.

Commencez toujours par le niveau 1, le script Apps Script basique et laissez-le tourner en mode observation pendant une semaine complète avant d'activer les refus réels. Si vos besoins sont simples et que votre agenda reçoit principalement des invitations sans description comme critère de filtrage principal, ce niveau suffira dans la grande majorité des cas.

Passez au niveau 2 (intégration Gemini) si vous constatez un taux élevé de faux positifs que les règles binaires ne gèrent pas bien, typiquement dans des environnements où les titres de réunion sont ambigus ou où les conventions d'invitation varient fortement selon les équipes.

Passez au niveau 3 (Python) si vous avez besoin de logs persistants sur plusieurs semaines, d'intégrations avec des outils externes, ou si vous gérez un volume d'événements qui dépasse les quotas d'Apps Script.

Dans tous les cas, la robustesse d'un système d'automatisation de calendrier se mesure autant à sa capacité à refuser ce qui doit l'être qu'à sa capacité à ne jamais toucher ce qui ne devrait pas l'être.

La liste blanche et les mots-clés de sécurité ne sont pas des options, ils sont le point de départ obligatoire avant toute ligne de code active.