Cómo usar Sleep en VBA para pausar una macro en Excel

Sleep no es una función de VBA: es una función de la API de Windows (kernel32) que VBA "toma prestada" para detener la ejecución de una macro unos milisegundos. Sirve para algo muy concreto: hacer que una macro lenta se vea lenta, en vez de parecer que se ha colgado mientras procesa doscientas hojas, escribe un informe largo o espera un archivo externo. Al terminar este tutorial sabrás declararla correctamente, medir la pausa y combinarla con bucles, MsgBox y Application.Wait para decidir cuándo conviene cada cosa. Funciona en Excel para Windows desde 2007; en Excel para Mac y en Excel para la web no está disponible (la API de Windows no existe ahí).

Qué hace Sleep en una macro y cuándo te interesa

Imagina una macro que abre un libro con doscientas hojas de presupuesto y, en cada una, recalcula totales, da formato y vuelve a guardar. Si la lanzas tal cual, Excel pasa diez segundos sin responder y el usuario no sabe si está trabajando o se ha quedado colgado. Ahí entra Sleep: detiene la macro un número de milisegundos y la deja seguir. Tú marcas el ritmo y el usuario ve cada avance.

Sleep es una función de Windows, no de VBA. Pertenece a la librería kernel32 y VBA la "importa" con una línea Declare. Una vez declarada, se usa como cualquier otra función: Sleep 3000 pausa la macro tres segundos exactos. La pausa es real: el reloj corre, pero el código no avanza ni un paso. Sirve para:

• Ritmo visible en macros que procesan muchos elementos (hojas, archivos, filas).
• Esperas técnicas mínimas al lanzar o cerrar un archivo externo desde VBA.
• Demostraciones y macros formativas, donde quieres que se vea cada cambio.

No sirve como temporizador fiable de minutos, ni para coordinar dos macros a la vez, ni como sustituto de una espera hasta una hora concreta: para eso ya están Application.Wait y OnTime. La idea es simple:.Sleep bloquea Excel entero durante los milisegundos que le digas; úsala en pausas cortas y dentro de bucles donde el usuario espera ver el progreso.

Sleep frente a Application.Wait: dos pausas distintas

Las dos pausan la macro, pero se parecen en poco más. Antes de elegir, mira esta tabla:

Usa Sleep cuando quieres milisegundos: pintar un número, mover un objeto en pantalla, separar dos acciones dentro de un mismo bucle. Usa Application.Wait cuando la pausa es larga y "redondeada" (esperar hasta las 12:00:00, esperar 30 segundos al abrir un libro externo), porque su sintaxis es con horas exactas y eso se entiende a la primera. Recuerda: Application.Wait redondea al segundo; si le pides 1,5 segundos, esperará dos.

Declarar Sleep desde kernel32 en tu libro

Sleep vive en kernel32, una librería de Windows, así que VBA necesita un "pasaporte" para usarla: la sentencia Declare. Se escribe una vez en un módulo estándar, al principio de todo, y a partir de ahí la usas en cualquier macro del libro.

El editor de VBA se abre con Alt+F11. Una vez dentro, la ruta para crear un módulo nuevo es:

La declaración cambia según tu Excel sea de 32 o de 64 bits (lo decides en Archivo > Cuenta > Acerca de Excel). Para que el mismo libro funcione en ambos, se envuelve en un bloque #If VBA7 Then:

La declaración de 64 bits

En la parte del #If VBA7 Then, en un Excel de 64 bits o en uno de 32 bits con la referencia a VBA7 activada:

#If VBA7 Then
    Public Declare PtrSafe Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As LongPtr)
#End If

PtrSafe es la palabra clave que dice "esta declaración es segura para 64 bits", y LongPtr es el tipo entero que se adapta al ancho de bits del Excel.

La declaración de 32 bits

En el #Else, la versión clásica que sirve en Excel de 32 bits y en Excel 2007:

#Else
    Public Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)
#End If

Una macro que mide el tiempo que pausa

Vamos a crear un libro que pausa y mide. Elige una carpeta, abre Excel en blanco y sigue los pasos.

Convertir el libro en un archivo con macros

1. Pulsa F12 para abrir Guardar como.
2. En Tipo, elige *Libro de Excel habilitado para macros (.xlsm)**.
3. Nombra el archivo, por ejemplo, Pausas.xlsm, y pulsa Guardar.

Ahora añade la declaración y la macro. Abre el editor con Alt+F11, inserta un módulo (Insertar > Módulo) y pega:

#If VBA7 Then
    Public Declare PtrSafe Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As LongPtr)
#Else
    Public Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)
#End If

Public Sub MedirSleep()
    Dim t1 As Date
    Dim t2 As Date
    t1 = Time
    MsgBox "Inicio: " & Format(t1, "hh:nn:ss")
    Sleep 10000
    t2 = Time
    MsgBox "Fin:    " & Format(t2, "hh:nn:ss")
End Sub

Pulsa F5 o Alt+F8 > MedirSleep > Ejecutar. Verás un MsgBox con la hora de inicio, Excel se queda "congelado" diez segundos (no responde ni a Esc ni a nada), y por fin aparece el segundo MsgBox con la hora final.

Verificar la pausa con el reloj de Windows

Anota la hora que muestra el primer MsgBox y la del segundo. La diferencia debe ser de diez segundos justos. Si miras el reloj de la barra de tareas de Windows mientras la macro está pausada, verás que los segundos pasan.

Inicio: 10:32:15
Fin:    10:32:25

Una pausa dentro de un bucle que escribe en la hoja

Ahora la pausa se ve "haciendo algo". Vamos a escribir números del 1 al 10 en la columna A, dejando tres segundos entre cada uno, y mostrar un aviso en cada paso. En la Hoja1 del libro Pausas.xlsm, parte de esta cuadrícula vacía:

Pega esta macro en el mismo módulo:

Public Sub BucleConPausa()
    Dim k As Long
    For k = 1 To 10
        Cells(k, 1).Value = k
        MsgBox "Fila escrita: " & k
        Sleep 3000
    Next k
    MsgBox "Terminado"
End Sub

Cada tres segundos, Excel muestra qué fila acaba de escribir y luego pausa. Verás la celda A1 pasar de 1 a 10 con el MsgBox en medio.

Bucle sin Sleep para comparar la velocidad

Quita la línea Sleep 3000 y añade una medición al principio y al final con la función Timer (segundos con decimales desde medianoche):

Public Sub BucleSinPausa()
    Dim k As Long
    Dim inicio As Single
    inicio = Timer
    For k = 1 To 10
        Cells(k, 1).Value = k
    Next k
    MsgBox "Duracion: " & Format(Timer - inicio, "0.00") & " s"
End Sub

Sin pausa tarda unas décimas de segundo. Con la pausa de tres segundos entre diez escrituras, la duración ronda los treinta segundos: la diferencia se ve entera.

Acelerar la macro mientras pausas

Pintar la hoja en cada iteración hace que Excel parpadee. Para evitarlo, abre las opciones del editor y desactiva el repintado de pantalla mientras la macro está "ocupada":

(Las propiedades que tocas están en el menú Herramientas > Propiedades de VBAProject, pero lo normal es controlarlas desde el propio código)

Public Sub BucleConPausaSilencioso()
    Dim k As Long
    Application.ScreenUpdating = False
    For k = 1 To 10
        Cells(k, 1).Value = k
        Sleep 3000
    Next k
    Application.ScreenUpdating = True
    MsgBox "Terminado"
End Sub

Con ScreenUpdating = False la hoja se queda "congelada" durante el bucle y solo se redibuja al final; combinado con Sleep el efecto es una pausa visual sin parpadeos. Si solo quieres evitar el parpadeo pero ver el progreso, deja ScreenUpdating = True y añade DoEvents justo después del Sleep para que Excel ventile mensajes pendientes.

Errores típicos al declarar y al usar Sleep

"Error de compilación: No se puede encontrar el proyecto o la biblioteca"

Verás este mensaje al abrir el módulo o al ejecutar la macro. La causa casi siempre es una declaración mal copiada: en un Excel de 64 bits falta PtrSafe y LongPtr, o al revés, en uno de 32 bits sobra. El arreglo es respetar el bloque #If VBA7 Then que se ha mostrado antes:

#If VBA7 Then
    Public Declare PtrSafe Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As LongPtr)
#Else
    Public Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)
#End If

"Error 1004 en tiempo de ejecución" al lanzar la macro

Suele aparecer porque la declaración Declare quedó dentro de un módulo de clase (los que están detrás de ThisWorkbook o Hoja1) en lugar de en un módulo estándar. VBA solo admite Declare en módulos estándar. El arreglo es mover la línea Declare al inicio de Módulo1 (o el nombre que le hayas puesto) y borrar la copia del módulo de clase.

La macro "se cuelga" y no responde ni a Escape

Esto no es un error, es el comportamiento normal de Sleep: la macro pide al sistema operativo que detenga el hilo de Excel durante X milisegundos, y durante esos milisegundos Excel no procesa teclas ni actualiza la pantalla. Si necesitas pausas interrumpibles (que el usuario pueda cancelar con Esc o un botón), sustituye Sleep por un bucle con DoEvents:

Public Sub PausaInterrumpible(ByVal segundos As Long)
    Dim fin As Single
    fin = Timer + segundos
    Do While Timer < fin
        DoEvents
    Loop
End Sub

DoEvents cede el control al sistema durante un instante, así Excel sí responde a la pulsación de Esc o a un clic en el botón Cancelar de un formulario. La duración es menos exacta que Sleep, pero la pausa se puede romper.

Lo que Sleep no hace y cuándo usar otra cosa

Sleep es muy concreta y conviene saber dónde se acaba:

• No es función de VBA. Hay que declararla con Declare PtrSafe y el bloque #If VBA7 Then cada vez que la quieras usar. Si lo olvidas, VBA no la reconoce.
• No acepta menos de 1 milisegundo de forma fiable. El reloj de Windows mide en pasos de 15-16 ms; por debajo de eso, la pausa puede ser 0 o 16, según el sistema.
• No se interrumpe. Mientras duerme, Excel está congelado: ni Esc, ni Ctrl+Inter, ni clic en la X. Si el usuario se arrepiente, debe esperar.
• No existe en Mac ni en Excel para la web. La API kernel32 es solo de Windows. En Mac usa Application.Wait o un bucle con Timer.
• No es un temporizador. Si necesitas que algo pase "a las 12:00", Application.OnTime es lo correcto, no Sleep.

En resumen: Sleep es la herramienta para milisegundos visibles dentro de una macro; para todo lo demás, VBA ya tiene su propia pieza.

Lo que ya sabes hacer con Sleep en VBA

• Declarar la función Sleep desde kernel32 con PtrSafe y el bloque #If VBA7 Then para que funcione en 32 y 64 bits.
• Pausar una macro un número exacto de milisegundos con Sleep 3000 y medir esa pausa con Time o Timer.
• Combinar Sleep con bucles For, MsgBox y Application.ScreenUpdating para que el usuario vea el progreso sin parpadeos.
• Elegir entre Sleep, Application.Wait y un bucle con DoEvents según necesites milisegundos exactos, esperar una hora, o permitir que el usuario cancele.

El siguiente paso natural es una macro que recorra varios libros de una carpeta, abra cada uno, haga un cambio visible (por ejemplo, escribir la fecha en una celda concreta) y aplique Sleep 2000 entre cada uno para que el usuario vea cómo se van abriendo uno a uno. Vas a reutilizar todo lo de este tutorial y a sumarle el trabajo con Workbooks.Open y Dir.

Datos comprobados en octubre de 2026.

Dudas al usar Sleep en una macro de Excel