# Macro VBA Excel : enregistrer, écrire et fiabiliser vos premières automatisations

> Créez votre première macro VBA dans Excel : onglet Développeur, enregistreur, éditeur VBE, variables, boucles, débogage et code généré avec ChatGPT.

- URL : https://guides-numeriques.fr/bureautique/macro-vba-excel/
- Thématique : Bureautique & collaboration
- Mis à jour : 2026-09-26
- Formation associée : [Apprendre VBA Excel - Créer des macros sans coder](https://espritacademique.com/formations/apprendre-vba-excel-creer-des-macros-sans-coder/)

## L'essentiel

- Une macro VBA Excel est un programme écrit en Visual Basic for Applications qui exécute automatiquement une suite d'actions dans un classeur.
- L'enregistreur de macros, dans l'onglet Développeur, transforme vos clics en code VBA : c'est la porte d'entrée la plus simple pour apprendre.
- Un classeur contenant des macros doit être enregistré au format .xlsm, sinon le code est supprimé à l'enregistrement.
- Les bases de la programmation VBA tiennent en quatre notions : variables, conditions (If, Select Case), boucles (For, For Each, Do) et objets Excel (Workbook, Worksheet, Range).
- ChatGPT et Copilot écrivent du VBA rapidement, mais le code doit être relu, testé pas à pas avec F8 et exécuté d'abord sur une copie du fichier.

Une **macro VBA Excel** est un petit programme qui exécute automatiquement une suite d'actions dans un classeur : mettre en forme un export, consolider des feuilles, générer des PDF, signaler des retards. Elle s'écrit en VBA (Visual Basic for Applications), le langage d'automatisation d'Excel, et peut être créée sans connaissances préalables grâce à l'enregistreur de macros.

Ce guide s'adresse aux utilisateurs d'Excel qui répètent chaque semaine les mêmes manipulations et veulent les automatiser. Vous apprendrez à préparer Excel, enregistrer une première macro, lire et améliorer le code, écrire vos propres procédures avec variables, conditions et boucles, les déboguer, et utiliser ChatGPT pour aller plus vite sans perdre le contrôle.

## Qu'est-ce qu'une macro VBA ?

Une macro VBA est une procédure, délimitée par `Sub` et `End Sub`, qui contient des instructions exécutées l'une après l'autre par Excel. Elle est stockée dans un module du classeur et peut être lancée par un raccourci, un bouton ou un événement, comme l'ouverture du fichier. Le VBA manipule des objets : classeurs, feuilles, plages de cellules, graphiques.

La logique est toujours la même : **un objet, une propriété ou une méthode**. Par exemple, `Range("A1").Font.Bold = True` met en gras la cellule A1 : l'objet est la plage A1, la propriété est la police en gras.

## À quoi sert une macro VBA dans Excel ?

Les macros sont rentables dès qu'une tâche est répétitive, identique et chronophage :

- **Mettre en forme un export** brut en un clic : largeurs, formats, en-têtes, filtres.
- **Consolider** les feuilles de plusieurs classeurs dans un fichier de synthèse.
- **Générer des documents** : un PDF par client, un onglet par commercial.
- **Contrôler des données** : signaler les factures en retard, les doublons, les cellules vides.
- **Envoyer des e-mails** via Outlook à partir d'une liste Excel.
- **Créer des outils** pour des collègues : formulaires de saisie, boutons de navigation.

## Créer une macro VBA Excel : les étapes

Exemple fil rouge : un fichier de factures avec les colonnes N°, Client, Montant, Échéance, Statut et Alerte.


**Schéma — Créer une macro VBA Excel en 6 étapes**

1. **Afficher Développeur** : Fichier > Options > Personnaliser le ruban
2. **Sécurité et format** : Macros avec notification, fichier .xlsm
3. **Enregistrer une macro** : Développeur > Enregistrer une macro
4. **Lire et nettoyer le code** : Éditeur VBA avec Alt+F11
5. **Tester et déboguer** : F8 pas à pas, F9 point d'arrêt, sur une copie
6. **Lancer d'un clic** : Alt+F8 ou bouton affecté à la macro


### Étape 1 — Afficher l'onglet Développeur

L'onglet est masqué par défaut. **Fichier > Options > Personnaliser le ruban**, puis cochez **Développeur** dans la liste de droite. Il contient les commandes Visual Basic, Macros, Enregistrer une macro, Insérer (boutons et contrôles) et Sécurité des macros.

### Étape 2 — Régler la sécurité et le format de fichier

Dans **Développeur > Sécurité des macros**, le réglage recommandé est **Désactiver les macros VBA avec notification** : Excel affiche un bandeau vous permettant d'activer le contenu des fichiers auxquels vous faites confiance. Pour vos propres dossiers de travail, vous pouvez ajouter un **emplacement approuvé** dans le Centre de gestion de la confidentialité.

Enregistrez le classeur au format **Classeur Excel (prenant en charge les macros) (.xlsm)**. Un fichier .xlsx ne peut pas contenir de code : Excel le supprime à l'enregistrement, après un simple avertissement.

### Étape 3 — Enregistrer une première macro

**Développeur > Enregistrer une macro**. Donnez un nom sans espace (*MiseEnFormeFactures*), éventuellement un raccourci, et choisissez où la stocker : **Ce classeur**, ou le **Classeur de macros personnelles** pour qu'elle soit disponible dans tous vos fichiers.

Effectuez vos manipulations : en-têtes en gras avec un fond coloré, format monétaire sur les montants, ajustement des colonnes. Puis **Arrêter l'enregistrement**. Le bouton **Utiliser les références relatives**, à activer avant d'enregistrer, rend les actions relatives à la cellule active plutôt qu'à des adresses fixes.

### Étape 4 — Découvrir l'éditeur VBA

**Alt+F11** ouvre l'éditeur Visual Basic (VBE). À gauche, l'**Explorateur de projets** liste les classeurs ouverts, leurs feuilles et leurs **modules** ; en dessous, la fenêtre **Propriétés**. Double-cliquez sur *Module1* : le code enregistré apparaît.

```vba
Sub MiseEnFormeFactures()
    Range("A1:F1").Select
    Selection.Font.Bold = True
    With Selection.Interior
        .Color = RGB(221, 235, 247)
    End With
    Range("C2:C500").Select
    Selection.NumberFormat = "#,##0.00 €"
    Columns("A:F").EntireColumn.AutoFit
End Sub
```

### Étape 5 — Nettoyer le code enregistré

L'enregistreur reproduit chaque clic, d'où les nombreux `Select` et `Selection`. Ils ralentissent l'exécution et rendent la macro fragile. La version optimisée agit directement sur les objets :

```vba
Sub MiseEnFormeFactures()
    With ActiveSheet
        With .Range("A1:F1")
            .Font.Bold = True
            .Interior.Color = RGB(221, 235, 247)
        End With
        .Range("C2:C500").NumberFormat = "#,##0.00 €"
        .Columns("A:F").AutoFit
    End With
End Sub
```

C'est l'exercice le plus formateur pour débuter : enregistrer, lire, simplifier. Vous comprenez ainsi le nom des objets et des propriétés sans avoir à les chercher.

### Étape 6 — Écrire une macro avec variables, condition et boucle

Passons à une macro impossible à enregistrer : parcourir toutes les factures et signaler celles qui sont en retard.

```vba
Option Explicit

Sub SignalerRetards()
    Dim ws As Worksheet
    Dim derniereLigne As Long
    Dim i As Long
    Dim nbRetards As Long

    Set ws = ThisWorkbook.Worksheets("Factures")
    derniereLigne = ws.Cells(ws.Rows.Count, "A").End(xlUp).Row

    For i = 2 To derniereLigne
        If ws.Cells(i, "E").Value = "Non payée" And ws.Cells(i, "D").Value < Date Then
            ws.Cells(i, "F").Value = "En retard"
            ws.Rows(i).Interior.Color = RGB(255, 199, 206)
            nbRetards = nbRetards + 1
        Else
            ws.Cells(i, "F").ClearContents
            ws.Rows(i).Interior.ColorIndex = xlNone
        End If
    Next i

    MsgBox nbRetards & " facture(s) en retard.", vbInformation
End Sub
```

Chaque élément a son rôle : `Option Explicit` oblige à déclarer les variables (et détecte les fautes de frappe), `Dim` déclare les variables avec leur type, la ligne `derniereLigne` trouve automatiquement la fin des données, la boucle `For` parcourt chaque ligne et le `If` applique la règle.

### Étape 7 — Tester et déboguer

Ne lancez jamais une nouvelle macro d'un coup sur vos vraies données. Dans le VBE :

- **F8** exécute le code ligne par ligne : la ligne en cours est surlignée en jaune ;
- **F9** pose un **point d'arrêt** : l'exécution s'arrête à cette ligne ;
- survolez une variable pour voir sa valeur, ou ajoutez-la dans la **fenêtre Espions** ;
- **Ctrl+G** ouvre la **fenêtre Exécution**, où `Debug.Print` affiche des valeurs intermédiaires ;
- **Débogage > Compiler VBAProject** détecte les erreurs de syntaxe avant l'exécution.

Attention : une macro ne peut pas être annulée avec Ctrl+Z. Travaillez sur une copie du fichier tant que la macro n'est pas validée.

### Étape 8 — Lancer la macro d'un clic

**Alt+F8** affiche la liste des macros à exécuter. Pour un usage quotidien, créez un bouton : **Développeur > Insérer > Bouton (contrôle de formulaire)**, tracez-le, puis choisissez la macro à affecter. Vous pouvez aussi utiliser une forme (Insertion > Formes), clic droit > **Affecter une macro**, plus facile à mettre en forme.

> **Formation recommandée** : [Apprendre VBA Excel - Créer des macros sans coder](https://espritacademique.com/formations/apprendre-vba-excel-creer-des-macros-sans-coder/) — 2h00 de vidéo, 45 €.

## Les notions de programmation VBA à connaître

Une fois la première macro écrite, voici les notions à approfondir pour gagner en autonomie.


**Schéma — Les 4 notions de base de la programmation VBA**

Programmation VBA :
- **Variables** : Dim, types de données, Option Explicit
- **Conditions** : If Then Else, Select Case
- **Boucles** : For Next, For Each, Do Loop
- **Objets Excel** : Workbook, Worksheet, Range


### Les variables et leurs types

| Type | Contenu | Exemple d'usage |
|---|---|---|
| `Long` | Nombre entier (grande plage) | Numéro de ligne, compteur |
| `Integer` | Nombre entier (petite plage) | Préférez Long pour les lignes, qui dépassent vite la limite |
| `Double` | Nombre décimal | Montant, taux |
| `String` | Texte | Nom de client, chemin de fichier |
| `Boolean` | Vrai ou Faux | Indicateur « trouvé » |
| `Date` | Date et heure | Échéance |
| `Worksheet`, `Range` | Objets Excel (avec `Set`) | Feuille de travail, plage à traiter |
| `Variant` | Tout type | Tableaux de valeurs, à réserver à ces cas |

La **portée** compte aussi : une variable déclarée dans une procédure n'existe que pendant son exécution ; déclarée en haut du module, elle est partagée par toutes les procédures de ce module.

### Conditions et opérateurs logiques

`If … ElseIf … Else … End If` couvre la plupart des cas. Quand une même variable est testée contre plusieurs valeurs, `Select Case` est plus lisible :

```vba
Select Case montant
    Case Is >= 10000
        categorie = "Grand compte"
    Case 2000 To 9999.99
        categorie = "Régulier"
    Case Else
        categorie = "Occasionnel"
End Select
```

Les opérateurs `And`, `Or` et `Not` combinent les conditions. Piège classique : VBA évalue toujours les deux côtés d'un `And`, même si le premier est faux. Un test comme `If ws.Cells(i, 3).Value <> 0 And 100 / ws.Cells(i, 3).Value > 5` provoque donc une erreur de division par zéro : imbriquez deux `If` à la place.

### Boucles et texte

`For … Next` parcourt un compteur, `For Each` parcourt une collection (chaque feuille, chaque cellule d'une plage), `Do Until` répète jusqu'à ce qu'une condition soit remplie. Côté texte, les fonctions `Len`, `Left`, `Right`, `Mid`, `Trim`, `Replace`, `UCase` et `InStr` couvrent l'essentiel du nettoyage.

### Les tableaux pour la performance

Lire et écrire les cellules une par une est lent sur des milliers de lignes. La bonne pratique consiste à charger la plage dans un tableau en mémoire, à traiter le tableau, puis à réécrire en une seule fois :

```vba
Dim donnees As Variant
donnees = ws.Range("A2:F" & derniereLigne).Value   ' tableau à 2 dimensions
For i = 1 To UBound(donnees, 1)
    donnees(i, 2) = UCase(Trim(donnees(i, 2)))     ' colonne Client nettoyée
Next i
ws.Range("A2:F" & derniereLigne).Value = donnees
```

La fonction `Split`, qui découpe un texte selon un séparateur, et `Array`, qui crée une liste de valeurs, complètent la panoplie.

### Structurer un code propre et réutilisable

Une macro qui fonctionne n'est pas forcément une macro maintenable. Quelques règles évitent les scripts confus que personne n'ose plus modifier six mois plus tard :

- **Une procédure, une tâche.** Plutôt qu'une macro de 200 lignes, écrivez plusieurs procédures courtes (importer, nettoyer, mettre en forme) appelées par une procédure principale avec `Call`.
- **Des fonctions pour les calculs répétés.** Une `Function` renvoie une valeur et peut même être utilisée dans une cellule comme une fonction Excel classique.
- **Des noms explicites.** `derniereLigne` et `wsFactures` se lisent seuls ; `x` et `ws2` obligent à remonter le code.
- **Aucune adresse en dur quand c'est évitable.** Calculez la dernière ligne, utilisez les noms de tableaux Excel ou des constantes déclarées en haut du module.
- **Des commentaires utiles.** Expliquez le « pourquoi » (une règle de gestion), pas le « quoi » que le code dit déjà.
- **Un gain de vitesse simple.** Encadrez les traitements lourds par `Application.ScreenUpdating = False` puis `True`, pour éviter le rafraîchissement de l'écran à chaque action.

Ces principes comptent encore plus lorsque le code est généré par l'IA : demandez explicitement une structure en procédures courtes et des noms de variables en français, vous relirez le résultat bien plus facilement.

Si vous n'êtes pas encore à l'aise avec les formules et la structure des données, reprenez d'abord notre feuille de route pour [apprendre Excel](https://guides-numeriques.fr/bureautique/apprendre-excel/) : une macro ne vaut que par la qualité du classeur qu'elle automatise.

## Créer une macro VBA avec ChatGPT

L'IA accélère considérablement l'écriture de VBA, à condition de lui donner un cahier des charges précis :

```text
Écris une macro VBA pour Excel, commentée en français, avec Option Explicit.
Feuille "Factures", données à partir de la ligne 2, colonnes : A N°,
B Client, C Montant, D Échéance, E Statut. Pour chaque client, crée une
nouvelle feuille portant son nom et copie-y ses factures avec l'en-tête.
Si la feuille existe déjà, vide-la avant de copier. Gère les noms de
clients contenant des caractères interdits dans un nom de feuille.
```

Ensuite, adoptez la même discipline qu'avec votre propre code : lisez chaque ligne, demandez à l'IA d'expliquer ce que vous ne comprenez pas, testez pas à pas sur une copie. Vous pouvez aussi lui soumettre une macro existante pour la **simplifier**, la **documenter** ou y ajouter une **gestion d'erreurs** (`On Error GoTo`). Pour d'autres usages de l'IA avec le tableur, consultez nos guides pour [automatiser Excel avec ChatGPT](https://guides-numeriques.fr/ia/automatiser-excel-chatgpt/) et sur l'[intelligence artificielle dans Excel](https://guides-numeriques.fr/bureautique/excel-intelligence-artificielle/).

## Les erreurs fréquentes en VBA (et comment les corriger)

| Message ou symptôme | Cause habituelle | Solution |
|---|---|---|
| Macros désactivées au lancement | Réglage de sécurité ou fichier issu d'Internet | Activer le contenu, ou débloquer le fichier dans ses propriétés Windows |
| Le code a disparu | Fichier enregistré en .xlsx | Toujours enregistrer en .xlsm |
| Erreur 9 : L'indice n'appartient pas à la sélection | Nom de feuille ou de classeur erroné | Vérifier l'orthographe exacte, espaces compris |
| Erreur 13 : Incompatibilité de type | Texte là où un nombre est attendu | Contrôler les données, utiliser `IsNumeric` ou `CDbl` |
| Erreur 91 : Variable objet non définie | Oubli de `Set` devant un objet | `Set ws = …` pour toute variable objet |
| Erreur 1004 | Plage ou opération invalide sur la feuille | Vérifier la feuille active et les références |
| Macro très lente | Nombreux `Select`, écriture cellule par cellule | Supprimer les Select, utiliser des tableaux, `Application.ScreenUpdating = False` |

## VBA, Office Scripts ou Power Query : quel outil choisir ?

VBA n'est pas toujours la meilleure réponse. Le bon outil dépend de la tâche et de l'environnement.

| Besoin | Outil recommandé |
|---|---|
| Importer et nettoyer des données chaque mois | Power Query, sans code |
| Automatiser des actions dans Excel de bureau | VBA |
| Piloter Outlook, Word ou des fichiers locaux | VBA |
| Automatiser dans Excel pour le web ou planifier dans le cloud | Office Scripts |
| Relier des tables et calculer des indicateurs | Power Pivot et DAX |

Si votre besoin se limite à importer et transformer des données, commencez par [Power Query et Power Pivot](https://guides-numeriques.fr/bureautique/power-query-power-pivot-excel/) : c'est plus simple et plus robuste qu'une macro. Pour les classeurs partagés dans le cloud, notre guide [Office Scripts Excel](https://guides-numeriques.fr/automatisation/office-scripts-excel/) présente l'alternative moderne à VBA.

## Comment apprendre VBA efficacement ?

Voici le parcours que nous recommandons :

1. **Fondations** : onglet Développeur, sécurité, enregistreur, lecture et nettoyage du code enregistré.
2. **Programmation** : variables et types, conditions, opérateurs logiques, fonctions de texte.
3. **Traitement en série** : boucles For, For Each et Do, tableaux simples puis à deux dimensions.
4. **Fiabilité** : débogage pas à pas, gestion des erreurs, code structuré en procédures réutilisables.
5. **Productivité** : génération, correction et documentation du code avec ChatGPT.

Pour suivre ce parcours avec des exercices à chaque étape, [la formation VBA Excel pour créer des macros sans être développeur](https://espritacademique.com/formations/apprendre-vba-excel-creer-des-macros-sans-coder/) d'EspritAcadémique le couvre en deux heures, sans prérequis. Elle aborde notamment :

- la préparation d'Excel, l'éditeur VBE et le passage de l'enregistreur au code maîtrisé ;
- le test et le débogage pas à pas, avec les erreurs les plus courantes ;
- les variables numériques, booléennes et texte, leur portée et leurs conversions ;
- les conditions If et Select Case, les opérateurs logiques et les fonctions de texte ;
- les boucles et les tableaux simples ou multidimensionnels pour traiter des volumes importants ;
- l'utilisation de ChatGPT pour générer, corriger, optimiser et documenter vos macros.

## En résumé

Une macro VBA Excel automatise les tâches répétitives de vos classeurs. Commencez par l'enregistreur pour découvrir le code, nettoyez-le pour en comprendre la logique, puis écrivez vos propres procédures avec variables, conditions et boucles. Testez toujours pas à pas sur une copie, enregistrez en .xlsm, et utilisez ChatGPT comme accélérateur, jamais comme substitut à la relecture.

## Sources et documentation officielle

- [Démarrage rapide : créer une macro (Support Microsoft)](https://support.microsoft.com/fr-fr/excel/get-started-with-excel/quick-start-create-a-macro)
- [Activer ou désactiver les macros dans les fichiers Microsoft 365 (Support Microsoft)](https://support.microsoft.com/fr-fr/office/vba/enable-or-disable-macros-in-microsoft-365-files)
- [Prise en main de VBA dans Office (Microsoft Learn)](https://learn.microsoft.com/fr-fr/office/vba/library-reference/concepts/getting-started-with-vba-in-office)
- [Modèle objet Excel pour Visual Basic pour Applications (Microsoft Learn)](https://learn.microsoft.com/fr-fr/office/vba/api/overview/Excel/object-model)

## Questions fréquentes

### Comment activer les macros dans Excel ?

Allez dans Fichier > Options > Centre de gestion de la confidentialité > Paramètres du Centre de gestion de la confidentialité > Paramètres des macros. Le réglage recommandé est de désactiver les macros avec notification : un bandeau vous propose alors de les activer pour chaque fichier de confiance. Pour un fichier téléchargé depuis Internet, il faut aussi le débloquer dans ses propriétés Windows.

### Quelle différence entre une macro et VBA ?

Une macro est une procédure qui automatise une tâche dans Excel. VBA (Visual Basic for Applications) est le langage dans lequel cette macro est écrite. Quand vous utilisez l'enregistreur, Excel écrit le code VBA à votre place. En apprenant le langage, vous pouvez modifier ce code, ajouter des conditions et des boucles, et créer des macros impossibles à enregistrer.

### Peut-on apprendre VBA sans savoir programmer ?

Oui. L'enregistreur de macros permet de démarrer sans écrire une ligne de code, puis d'observer le code produit pour comprendre la logique. Les notions de programmation nécessaires (variables, conditions, boucles) sont limitées et s'apprennent progressivement. Avec deux heures de formation guidée, un utilisateur d'Excel sans expérience du code peut écrire ses premières macros utiles.

### Les macros VBA fonctionnent-elles sur Excel pour le web ou sur Mac ?

Les macros VBA ne s'exécutent pas dans Excel pour le web : il faut Excel de bureau. Sur Mac, VBA fonctionne, mais certaines instructions propres à Windows (accès à certains objets système ou contrôles) ne sont pas prises en charge. Pour automatiser dans Excel pour le web, Microsoft propose Office Scripts, fondé sur TypeScript.

### ChatGPT peut-il écrire une macro VBA fiable ?

ChatGPT produit souvent un code fonctionnel si la demande est précise : noms des feuilles, colonnes concernées, règle à appliquer, cas particuliers. Mais il peut se tromper sur une référence, oublier un cas vide ou inventer une propriété. Relisez le code, demandez des commentaires ligne par ligne, testez pas à pas avec F8 et exécutez-le toujours d'abord sur une copie.

### Combien de temps faut-il pour apprendre VBA ?

Quelques heures suffisent pour enregistrer, lire et adapter des macros simples. Comptez deux heures de formation guidée pour couvrir les variables, les conditions, les boucles, le débogage et l'usage de ChatGPT, puis quelques semaines de pratique régulière sur vos propres fichiers pour écrire des macros robustes de façon autonome.
