# Comment utiliser VBA SendKeys pour automatiser vos actions
L’automatisation des tâches répétitives représente un enjeu majeur pour optimiser la productivité dans l’environnement bureautique moderne. La méthode SendKeys de Visual Basic for Applications (VBA) constitue une solution accessible pour simuler des frappes clavier et interagir avec des applications Windows. Bien que cette technique comporte certaines limitations techniques, elle demeure un outil précieux pour les développeurs cherchant à automatiser des processus impliquant plusieurs logiciels. Comprendre les subtilités de SendKeys, ses codes spéciaux et ses meilleures pratiques d’implémentation permet de créer des scripts robustes capables d’effectuer des tâches complexes sans intervention manuelle. Cette approche trouve des applications concrètes dans de nombreux secteurs professionnels, du traitement de données à la gestion documentaire.
Comprendre la méthode SendKeys dans l’environnement VBA excel
La méthode SendKeys appartient à l’objet Application dans VBA et permet d’envoyer des séquences de touches vers l’application actuellement active. Son fonctionnement repose sur un principe simple : elle place les frappes dans une mémoire tampon que Windows transmet ensuite à la fenêtre disposant du focus. Cette technique s’avère particulièrement utile lorsque vous devez interagir avec des éléments d’interface ne disposant pas d’API programmatique ou lorsque les méthodes natives VBA ne peuvent accomplir la tâche souhaitée.
L’utilisation de SendKeys nécessite une compréhension précise du timing et de la gestion du focus applicatif. Contrairement aux interactions directes avec les objets Excel, cette méthode dépend fortement de l’état actuel de l’interface utilisateur. Si une autre fenêtre intercepte le focus pendant l’exécution, les touches seront envoyées vers cette fenêtre au lieu de la destination prévue, causant des résultats imprévisibles.
Syntaxe complète de Application.SendKeys et ses paramètres wait
La syntaxe de base de SendKeys se présente comme suit : Application.SendKeys(Keys, Wait). Le premier paramètre, obligatoire, correspond à une expression de chaîne spécifiant les séquences de touches à envoyer. Le second paramètre, facultatif, est une valeur booléenne déterminant si Excel doit attendre le traitement complet des touches avant de continuer l’exécution du code. Par défaut, ce paramètre est défini sur False, permettant à la procédure de se poursuivre immédiatement après l’envoi.
Lorsque vous définissez le paramètre Wait sur True, votre macro suspend son exécution jusqu’à ce que l’application cible ait traité toutes les frappes transmises. Cette configuration s’avère cruciale dans les scénarios où les actions suivantes dépendent du résultat de la saisie clavier. Par exemple, si vous envoyez des données vers une boîte de dialogue puis tentez immédiatement de valider avec Enter, définir Wait sur True garantit que les données sont bien présentes avant la validation.
Différences entre SendKeys VBA et WScript.Shell.SendKeys
Deux implémentations principales de SendKeys coexistent dans l’écosystème Windows : la méthode native VBA et celle accessible via l’objet WScript.Shell. La méthode WScript.Shell nécessite la création d’une instance de l’objet avec CreateObject("WScript.Shell") et présente l’avantage de contourner certaines restrictions de sécurité rencontrées avec la version native. Cette approche alternative devient particulièrement pertinente dans les environnements où les paramètres de sécurité bloquent l’utilisation directe de Application.SendKeys.
En termes de performances, WScript.
En pratique, les deux versions de SendKeys reposent sur le même principe de file de messages Windows, mais leur contexte d’exécution diffère. Application.SendKeys reste cantonné à Excel (ou à l’hôte Office courant), tandis que WScript.Shell.SendKeys est souvent utilisé dans des scripts VBS ou depuis VBA pour piloter plus facilement des applications externes. Vous pouvez par exemple déclarer un objet shell en haut de module pour factoriser vos appels :
Dim Wsh As ObjectSet Wsh = CreateObject("WScript.Shell")Wsh.SendKeys "^s" ' Simule Ctrl+SDans certains environnements verrouillés, vous constaterez que Application.SendKeys renvoie une erreur « Permission refusée », alors que le même enchaînement passe avec WScript.Shell.SendKeys. Cela ne doit cependant pas vous pousser à en abuser : quelle que soit la variante, SendKeys reste sensible au focus et donc intrinsèquement fragile. Utilisez-le comme une béquille ponctuelle, pas comme le socle de toute votre architecture d’automatisation.
Codes spéciaux pour les touches modificatrices : +, ^, % et ()
Pour exploiter pleinement VBA SendKeys, il est indispensable de maîtriser les codes spéciaux pour les touches modificatrices. Trois symboles principaux permettent de simuler les raccourcis les plus courants : + pour Maj (Shift), ^ pour Ctrl et % pour Alt. Ainsi, la combinaison Ctrl+S s’écrit "^s", Alt+F4 devient "%{F4}", et Maj+Tab se traduit par "+{TAB}".
Les parenthèses jouent un rôle clé lorsqu’il s’agit de maintenir une touche modificatrice pendant plusieurs frappes. Si vous écrivez "+(abc)", cela revient à maintenir Maj pendant la saisie de abc, produisant « ABC ». De même, vous pouvez combiner plusieurs modificateurs : "^%(n)" simule par exemple Ctrl+Alt+n. Imaginez les parenthèses comme un « groupe » de touches pressées sous la même combinaison, à la manière d’une accolade qui englobe une suite d’actions coordonnées.
Limitations techniques de SendKeys face aux applications 64-bit
Depuis la généralisation de Windows 64 bits et d’Office 64 bits, certains utilisateurs s’étonnent de comportements erratiques de SendKeys. La vérité, c’est que la méthode SendKeys n’est pas directement « 64-bit aware » : elle se contente d’envoyer des messages clavier à la fenêtre active, sans se préoccuper de l’architecture du processus cible. Là où les choses se compliquent, c’est lorsque des contrôles 64 bits ou des technologies de virtualisation de fenêtre interceptent ou filtrent ces messages.
Concrètement, vous pouvez rencontrer des cas où une application 64 bits (par exemple un client SAP 64 bits ou un vieux progiciel migré) ignore partiellement certaines séquences SendKeys ou les traite avec un décalage temporel important. Dans ces contextes, augmenter les délais d’attente (Wait, Application.Wait, voire Sleep) améliore parfois la fiabilité, mais ne règle pas tout. C’est un peu comme essayer d’ouvrir une porte de coffre-fort avec un tournevis : vous arriverez peut‑être à déclencher un mécanisme, mais ce ne sera jamais aussi robuste qu’une API prévue à cet effet.
Automatiser la saisie clavier dans les applications windows avec SendKeys
Une fois les bases posées, l’utilisation de VBA SendKeys prend tout son sens lorsqu’il s’agit de piloter d’autres applications Windows depuis Excel. Vous pouvez automatiser la saisie dans Notepad, Word, Outlook ou même des ERP propriétaires, dès lors qu’ils réagissent au clavier. L’idée consiste souvent à préparer les données dans Excel, à donner le focus à l’application cible (avec AppActivate) puis à injecter les frappes nécessaires pour simuler l’action de l’utilisateur.
Cette approche est particulièrement utile lorsque vous devez répéter une opération identique des dizaines de fois par jour. Plutôt que de ressaisir manuellement des informations, pourquoi ne pas laisser un script VBA le faire pour vous ? Vous gagnez du temps, vous réduisez les erreurs de saisie et vous normalisez la procédure. Gardez toutefois en tête que tout changement d’interface ou de libellé de fenêtre dans l’application cible peut briser votre automatisation, d’où l’importance de tester régulièrement.
Transmission de données vers notepad et applications microsoft office
Notepad (Bloc‑notes) est souvent le terrain de jeu idéal pour apprivoiser la méthode SendKeys. Son interface minimaliste, dépourvue de contrôles complexes, réagit de manière prévisible aux frappes clavier. Un scénario simple consiste à ouvrir Notepad, attendre qu’il soit prêt, puis y envoyer un texte formaté depuis Excel :
Sub EnvoyerVersNotepad() Dim sh As Object Set sh = CreateObject("WScript.Shell") Shell "notepad.exe", vbNormalFocus Application.Wait Now + TimeValue("0:00:02") sh.AppActivate "Sans titre - Bloc-notes" sh.SendKeys "Texte envoyé depuis Excel via VBA SendKeys.{ENTER}" sh.SendKeys "Deuxième ligne de texte."End SubVous pouvez transposer exactement la même logique à Word, Outlook ou PowerPoint, par exemple pour automatiser l’envoi d’e-mails ou la création de comptes‑rendus. Dans Word, une fois le document actif, SendKeys peut appliquer des raccourcis clavier (comme Ctrl+B pour le gras) ou naviguer dans les menus avec Alt. L’automatisation inter‑applications s’apparente ici à un « copilote clavier » qui rejoue pour vous des gestes fastidieux, à condition de bien dompter le timing.
Contrôler les boîtes de dialogue système non accessibles via VBA
Un autre cas d’usage fréquent de SendKeys concerne les boîtes de dialogue système qui ne sont pas exposées via l’objet modèle VBA. Pensez par exemple à certaines boîtes « Ouvrir » ou « Enregistrer sous » de logiciels tiers, à des pop‑ups de confirmation de sécurité, ou encore à des fenêtres d’impression avancées. Dans ces cas, il n’existe souvent aucune méthode officielle pour renseigner les champs par code, et SendKeys devient la seule option raisonnable.
La stratégie typique consiste à déclencher l’action qui ouvre la boîte de dialogue, à insérer un court délai (Application.Wait), puis à envoyer la séquence de touches pour remplir les champs et valider. Par exemple, si une boîte d’enregistrement attend un nom de fichier puis la touche Entrée, vous pouvez faire :
Application.SendKeys "Rapport_Avril_2026"Application.SendKeys "{ENTER}"Dans ce type de scénario, la précision du timing est cruciale. Si la boîte de dialogue n’est pas encore prête à recevoir les frappes, celles‑ci partiront dans le vide ou se retrouveront dans une autre fenêtre. C’est pourquoi il est préférable de tester progressivement, en ajoutant d’abord des délais généreux, puis en les réduisant au fur et à mesure que vous validez le comportement sur plusieurs postes.
Simulation de raccourcis clavier Alt+Tab et Ctrl+V pour le workflow
Vous vous demandez peut‑être s’il est possible de simuler des combinaisons comme Alt+Tab pour changer d’application, ou Ctrl+V pour coller du presse‑papiers. La réponse est oui, mais avec prudence. Pour simuler un basculement vers la fenêtre précédente, on peut utiliser "%{TAB}" : % représente Alt et {TAB} la touche Tabulation. De la même façon, "^v" envoie le classique Ctrl+V, très utile après un Copy dans Excel.
Cependant, déclencher un Alt+Tab via SendKeys reste risqué, car vous perdez le contrôle exact de la fenêtre qui recevra ensuite le focus. Un simple clic de souris de l’utilisateur pendant l’exécution peut suffire à détourner le script. Pour de petits scripts personnels, cette approche peut dépanner, mais pour une automatisation professionnelle et partagée, mieux vaut s’appuyer sur AppActivate avec le titre précis de la fenêtre, plutôt que sur des enchaînements de Alt+Tab approximatifs.
Gérer le focus applicatif avec AppActivate avant SendKeys
La fonction AppActivate est le complément indispensable de VBA SendKeys pour fiabiliser l’automatisation multi‑applications. Elle permet de donner le focus à une fenêtre spécifique soit par son titre, soit par l’ID de processus retourné par Shell. Par exemple :
Dim pid As Longpid = Shell("calc.exe", vbNormalFocus)AppActivate pidApplication.SendKeys "123+456~"Dans cet exemple, on lance la Calculatrice Windows, on lui attribue le focus, puis on envoie la séquence pour calculer 123 + 456 et valider avec Enter (représenté par ~). C’est beaucoup plus fiable que de compter sur la simple ouverture de la fenêtre au premier plan. Une bonne pratique consiste à toujours enchaîner : Shell → courte pause → AppActivate → SendKeys. Vous réduisez ainsi drastiquement les risques que les frappes partent dans la mauvaise application.
Codes de touches spéciales et séquences complexes SendKeys
Pour construire des séquences complexes avec VBA SendKeys, il ne suffit pas de connaître les lettres et les modificateurs. Vous devez également maîtriser les codes des touches spéciales (fonction, navigation, suppression, etc.). Ces codes, généralement entourés d’accolades, vous permettent de recréer des parcours utilisateur sophistiqués dans des formulaires, des menus ou des interfaces de paramétrage.
On peut comparer cette panoplie de codes à un alphabet étendu : les lettres de A à Z ne suffisent pas à écrire un roman, il vous faut aussi des signes de ponctuation, des guillemets, des parenthèses. De la même manière, pour piloter finement une interface distante, vous aurez besoin de {TAB}, {ENTER}, {F5}, {UP}, etc. C’est la combinaison intelligente de ces éléments qui donne à SendKeys sa véritable puissance.
Mapper les touches fonctionnelles {F1} à {F12} et {ENTER}
Les touches de fonction de F1 à F12 jouent un rôle central dans de nombreuses applications métier. Avec SendKeys, elles se représentent simplement par {F1}, {F2}, …, {F12}. Vous pouvez ainsi déclencher des actions contextuelles comme l’aide en ligne (F1), la recherche (F3) ou le rafraîchissement d’un écran (F5) dans un ERP ou un CRM. Ces raccourcis, souvent propres à chaque logiciel, deviennent alors programmables depuis Excel.
La touche Entrée se code généralement avec "~" (tilde) ou explicitement avec "{ENTER}". Les deux notations sont équivalentes dans la majorité des cas, mais l’usage de {ENTER} rend votre code plus lisible, surtout dans des séquences longues. Par exemple :
Application.SendKeys "Client123{TAB}"Application.SendKeys "Commande456{ENTER}"Dans cet exemple, vous renseignez un champ « Client » puis un champ « Commande » avant de valider. En combinant touches fonctionnelles et {ENTER}, vous pouvez reproduire la plupart des scénarios de navigation qui s’effectuent uniquement au clavier dans les applications professionnelles.
Encoder les caractères spéciaux {}, [], () dans les chaînes SendKeys
Un aspect souvent source de confusion avec VBA SendKeys concerne la saisie de caractères qui ont une signification particulière pour la méthode elle‑même. Les plus importants sont : +, ^, %, (, ) et bien sûr les accolades { et }. Pour envoyer ces caractères « bruts » à l’application cible, vous devez les entourer d’accolades.
Par exemple, pour taper un signe plus dans une zone de texte, vous utiliserez "{+}" et non simplement "+", qui serait interprété comme la touche Maj. Les parenthèses se saisissent via "{(}" et "{)}". Pour les accolades elles‑mêmes, vous devrez les doubler : "{{}" pour { et "{}}" pour }. Quant aux crochets [ et ], même s’ils ne sont pas interprétés comme des codes spéciaux par SendKeys, la documentation recommande de les entourer d’accolades pour éviter tout conflit dans certains scénarios d’échange de données (DDE).
Utiliser {TAB}, {BACKSPACE} et {DELETE} pour la navigation formulaire
Les touches de navigation et de suppression jouent un rôle clé dans l’automatisation des formulaires, qu’il s’agisse de pages web, de boîtes de dialogue ou d’interfaces lourdes. La touche Tabulation, notée {TAB}, permet de passer d’un champ au suivant, alors que {SHIFT}+{TAB} (ou "+{TAB}") revient au champ précédent. Enchaîner plusieurs {TAB} vous permet de positionner le curseur exactement là où vous le souhaitez sans recourir à la souris.
Pour corriger ou effacer du texte, {BACKSPACE} (ou {BS}) supprime le caractère situé à gauche du curseur, tandis que {DELETE} (ou {DEL}) supprime celui de droite ou le texte sélectionné. Par exemple, pour effacer intégralement un champ avant de le remplir à nouveau, vous pouvez faire :
Application.SendKeys "^a" ' Sélectionner toutApplication.SendKeys "{DELETE}" ' EffacerApplication.SendKeys "Nouvelle valeur"Ce trio {TAB}, {BACKSPACE}, {DELETE}, combiné à Ctrl+A et à {ENTER}, vous donne une maîtrise fine de la navigation et de l’édition dans presque tous les environnements compatibles clavier.
Répétition de touches avec la syntaxe {LEFT 5} et accolades multiples
Lorsqu’une même touche doit être répétée plusieurs fois, SendKeys propose une syntaxe pratique : {touche nombre}. Par exemple, {LEFT 5} déplacera le curseur cinq fois vers la gauche, et {TAB 3} avancera de trois champs. Il est important de laisser un espace entre le nom de la touche et le nombre, sans quoi la commande ne sera pas interprétée correctement.
Cette fonctionnalité s’avère utile pour ajuster finement une position dans un champ, ou pour contourner une interface où le nombre d’appuis sur Tab est fixe mais élevé. Vous pouvez même combiner répétitions et modificateurs : "+{RIGHT 10}" sélectionnera les dix prochains caractères vers la droite. Visualisez cela comme un « clavier turbo » qui répète une touche à grande vitesse, tout en restant parfaitement déterministe.
Synchronisation temporelle et gestion des erreurs SendKeys
La fiabilité d’un script VBA SendKeys dépend autant de la séquence de touches envoyées que du timing avec lequel elles sont délivrées. Windows, les applications clientes et même l’antivirus peuvent introduire des latences imprévisibles, surtout sur des postes de travail chargés. Pour garantir que chaque frappe arrive au bon moment, vous devez donc intégrer une vraie stratégie de synchronisation temporelle et de gestion des erreurs.
On peut comparer cela à une chorégraphie : si un danseur démarre trop tôt ou trop tard, tout le numéro se désynchronise. De la même manière, un SendKeys mal temporisé peut se retrouver dans le mauvais champ, ou être interprété avant que la fenêtre ne soit prête. Les outils comme Wait, Sleep et les API de détection de fenêtre active vous aident à garder la cadence juste.
Implémenter Application.Wait et sleep API pour la stabilité d’exécution
Application.Wait est la méthode la plus simple pour insérer une pause dans vos macros SendKeys. Elle accepte une date/heure cible et bloque l’exécution jusqu’à ce moment : Application.Wait Now + TimeValue("0:00:02") crée par exemple une pause de deux secondes. Cette approche, bien que rudimentaire, suffit souvent à laisser le temps à une fenêtre de s’ouvrir ou à une boîte de dialogue de s’afficher avant l’envoi des frappes.
Pour des pauses plus courtes ou plus précises, il est courant de recourir à l’API Windows Sleep, déclarée ainsi dans un module standard (version 64 bits) :
#If VBA7 Then Private Declare PtrSafe Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As LongPtr)#Else Private Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)#End IfVous pouvez ensuite appeler Sleep 500 pour une pause de 500 millisecondes. L’astuce consiste à calibrer ces délais : trop courts, ils provoquent des aléas ; trop longs, ils rallongent inutilement le temps d’exécution global. Dans les projets critiques, on n’hésite pas à combiner Sleep avec des boucles de vérification de fenêtre pour ne pas attendre plus que nécessaire.
Détecter les fenêtres actives avec GetForegroundWindow API
Pour aller plus loin dans la synchronisation, vous pouvez vérifier que la bonne fenêtre est active avant d’envoyer vos touches. L’API GetForegroundWindow renvoie le handle (identifiant) de la fenêtre actuellement au premier plan. En le comparant au handle attendu, vous savez si le focus est bien là où vous le souhaitez.
Une déclaration typique ressemble à :
#If VBA7 Then Private Declare PtrSafe Function GetForegroundWindow Lib "user32" () As LongPtr#Else Private Declare Function GetForegroundWindow Lib "user32" () As Long#End IfVous pouvez ensuite interroger périodiquement cette fonction dans une boucle d’attente, jusqu’à ce que la fenêtre cible (récupérée par ailleurs via d’autres API ou via AppActivate) soit au premier plan. Cette technique réduit fortement le risque d’envoyer des séquences SendKeys à la mauvaise application, notamment lorsque l’utilisateur continue à travailler sur son poste pendant l’exécution du script.
Stratégies de débogage pour les échecs de transmission clavier
Déboguer un script basé sur SendKeys peut être déroutant, car les erreurs ne se manifestent pas toujours par des messages explicites. Vous constaterez plutôt un comportement « bizarre » de l’interface cible : champs mal remplis, raccourcis non déclenchés, boîtes de dialogue qui restent ouvertes. La première étape de débogage consiste à ralentir volontairement votre macro, à afficher des MsgBox entre chaque grande étape et à observer visuellement ce qui se passe.
Ensuite, vérifiez méthodiquement : le focus de la fenêtre (via AppActivate ou les API), la qualité de la chaîne SendKeys (caractères spéciaux bien encodés), les délais d’attente, et la cohérence du titre de la fenêtre cible (qui peut changer selon les versions ou les langues). N’hésitez pas à tester vos séquences SendKeys en les rejouant manuellement au clavier : si la procédure ne fonctionne déjà pas « à la main », elle ne fonctionnera pas mieux automatisée. Documenter vos scripts et inclure des journaux (logs) dans un fichier texte peut également aider à retracer précisément le scénario en cas de dysfonctionnement.
Alternatives modernes à SendKeys pour l’automatisation robuste
Malgré sa simplicité et sa polyvalence, VBA SendKeys n’est pas toujours la solution idéale pour automatiser des applications, surtout dans des environnements sensibles ou de grande envergure. Les technologies modernes privilégient des approches plus robustes : APIs officielles, automation COM, UI Automation, voire frameworks d’automatisation web. Ces outils offrent un contrôle fin sur les éléments d’interface sans passer par les frappes clavier, ce qui réduit drastiquement les risques d’erreurs liés au focus et au timing.
On peut voir SendKeys comme un « plan B » universel, utile lorsqu’aucune autre porte n’est ouverte, tandis que ces alternatives représentent des portes d’entrée principales, prévues et supportées par les éditeurs. Dans une démarche professionnelle, il est judicieux d’évaluer d’abord les options d’automatisation natives avant de recourir à SendKeys en dernier recours.
UI automation avec les bibliothèques windows automation API
Les Windows Automation API, et plus largement le framework UI Automation, permettent de piloter les applications en s’adressant directement à leurs contrôles (boutons, champs texte, listes, etc.). Plutôt que d’envoyer « Tab Tab Enter », vous pouvez, en théorie, cibler le bouton « OK » par son nom ou son AutomationId et déclencher un clic programmatique. Cette approche est beaucoup plus stable face aux changements d’interface ou aux variations de performance des postes.
Depuis VBA, l’utilisation directe de UI Automation demande cependant un certain investissement technique : il faut référencer les bonnes bibliothèques, manipuler des interfaces COM complexes et gérer les handles de fenêtre. Pour des projets stratégiques, ce surcoût est largement compensé par la robustesse obtenue. De nombreux éditeurs de logiciels de tests fonctionnels (Ranorex, TestComplete, etc.) reposent d’ailleurs sur ces APIs plutôt que sur un simple envoi de touches clavier.
Selenium WebDriver pour l’automatisation web versus SendKeys
Lorsqu’il s’agit d’automatiser des applications web (intranets, portails clients, back‑offices), Selenium WebDriver s’est imposé comme la référence. Plutôt que de simuler Tab et Enter dans un navigateur via SendKeys, vous pouvez sélectionner directement un champ de formulaire par son identifiant HTML et lui affecter une valeur avec .SendKeys() au sens Selenium, qui n’a rien à voir avec Application.SendKeys de VBA. Vous pouvez même déclencher un clic sur un bouton ou attendre explicitement qu’un élément soit visible.
Bien que Selenium ne soit pas nativement intégré à VBA, certains développeurs créent des ponts via PowerShell, Python ou C#, qu’ils appellent ensuite depuis Excel. L’effort initial est plus important, mais le gain de fiabilité est considérable, surtout pour des automatisations web répétitives ou critiques (saisie de commandes, mises à jour de référentiels, extractions régulières). En résumé, pour tout ce qui est purement web, Selenium WebDriver surclasse largement une approche SendKeys traditionnelle.
Autohotkey et AutoIt comme solutions externes complémentaires
AutoHotkey et AutoIt sont deux outils d’automatisation de bureau très populaires, capables de simuler clavier, souris et de manipuler les fenêtres de manière avancée. Ils offrent une syntaxe plus riche que SendKeys, avec des capacités de détection d’éléments d’interface, de gestion de fenêtres, de boucles d’attente et de conditions. Dans beaucoup de projets, la combinaison gagnante consiste à laisser Excel préparer les données, puis à déléguer l’automatisation de l’interface à un script AutoHotkey ou AutoIt.
Vous pouvez par exemple générer un fichier de script AutoIt depuis Excel, ou simplement appeler un script existant avec Shell ou WScript.Shell.Run, en lui passant des paramètres (chemins, identifiants, options). Cela permet de cloisonner les responsabilités : VBA gère la logique métier et la préparation des données, tandis qu’AutoHotkey/AutoIt se charge du pilotage fin de l’interface. Pour des automatisations complexes et évolutives, cette architecture hybride est souvent plus saine qu’un énorme script VBA rempli de SendKeys.
Cas pratiques avancés SendKeys dans des scénarios professionnels
Malgré l’existence d’alternatives plus modernes, VBA SendKeys conserve une place de choix dans de nombreux scénarios professionnels, notamment lorsqu’il faut « bricoler » rapidement une automatisation sur un logiciel fermé ou ancien. Dans cette dernière partie, nous allons passer en revue quelques cas pratiques avancés illustrant la manière dont SendKeys peut s’intégrer à des workflows métier concrets. Ces exemples ne sont pas des modèles absolus, mais des pistes que vous pouvez adapter à votre propre contexte.
Nous verrons notamment comment automatiser l’export PDF depuis Excel en passant par les menus natifs, comment piloter une interface SAP GUI ne disposant pas de module d’intégration standard, et comment contourner certaines restrictions macro dans des environnements fortement sécurisés. Chaque fois, la clé sera d’équilibrer le pragmatisme (utiliser SendKeys là où il brille) et la prudence (limiter sa portée, surveiller les erreurs et prévoir des plans de secours).
Automatiser l’export PDF depuis excel avec les menus fichier natifs
Dans certaines versions d’Excel ou dans des environnements verrouillés, l’export PDF via VBA peut être limité ou contrôlé par des compléments tiers. Plutôt que d’utiliser directement ExportAsFixedFormat, certains administrateurs préfèrent imposer le passage par le menu Fichier afin de respecter une configuration standardisée. Dans ce contexte, SendKeys peut simuler la navigation utilisateur dans les menus afin d’initier l’export.
Un scénario typique consiste à simuler la pression de Alt+F pour ouvrir le menu Fichier, puis de la lettre correspondant à « Enregistrer sous » ou « Exporter », selon la version et la langue d’Office. Ensuite, il s’agit de renseigner le nom du fichier, de sélectionner le format PDF (souvent via {TAB} et les flèches), puis de valider avec {ENTER}. Ce genre d’automatisation reste fragile face à des mises à jour d’Office, mais peut dépanner dans des environnements où les APIs classiques sont bloquées par des politiques de sécurité.
Remplissage automatique de formulaires SAP GUI via simulation clavier
De nombreuses entreprises s’appuient sur SAP GUI pour leurs processus financiers, logistiques ou RH. Bien que SAP propose des interfaces d’intégration plus robustes (BAPIs, IDocs, etc.), il arrive que certains services métiers n’y aient pas accès et doivent saisir manuellement des données provenant d’Excel. Dans ces cas, VBA SendKeys peut servir de solution intermédiaire pour accélérer la saisie et réduire les erreurs.
Le principe est d’identifier une transaction SAP à automatiser (par exemple la création de commandes), de repérer la séquence exacte de tabulations, de touches de fonction (F2, F3, F8, etc.) et d’entrées clavier nécessaires, puis de la reproduire via SendKeys. Un petit formulaire Excel permet de préparer les données (codes articles, quantités, centres, etc.), puis un bouton lance le script qui bascule sur SAP, remplit les champs et valide la transaction. Bien que cette approche reste sensible aux changements de configuration SAP, elle peut faire gagner un temps considérable dans des tâches répétitives bien cadrées.
Contourner les restrictions macro dans les environnements sécurisés
Dans certains environnements fortement sécurisés (banques, administrations), les macros Excel sont limitées ou soumises à des signatures numériques strictes. Les utilisateurs se retrouvent alors à exécuter manuellement des procédures longues dans des logiciels propriétaires, faute de pouvoir déployer des développements plus aboutis. Dans ce contexte, SendKeys peut être utilisé de manière ponctuelle pour automatiser des actions simples, sans nécessiter d’accès profond aux APIs des applications.
Par exemple, un script peut se contenter d’ouvrir un rapport standard dans un outil de reporting, de renseigner automatiquement quelques filtres temporels et de lancer l’export avant de rendre la main à l’utilisateur. Même si la macro ne peut pas enregistrer de fichiers sur le réseau ou accéder à certaines ressources, elle peut tout de même soulager la partie la plus répétitive de la procédure via des séquences clavier. La prudence reste de mise : il est essentiel de respecter les politiques de sécurité de l’entreprise et de documenter clairement ce que fait l’automatisation, afin de ne pas créer de « boîte noire » difficile à auditer.