Dividir un archivo de Excel grande en varios de ≤ 5 MB (manual, VBA y trucos de optimización)

¿Necesitas enviar, subir o archivar un Excel que pesa demasiado? Aquí tienes un método manual rápido y dos enfoques automáticos (VBA listo para usar y una versión “pro” auto‑calibrada) para dividir un libro grande en varios de ≤ 5 MB, más trucos finos para mantener cada parte ligera.

Índice

Resumen de la pregunta

¿Cómo partir un libro de Excel muy grande en varios archivos más pequeños, asegurando que cada uno pese como máximo 5 MB?

Soluciones en un vistazo

Método	Cuándo usarlo	Ventajas	Advertencias
Manual (copiar/pegar)	Una vez, tamaño moderado	Sin programar, control visual	Lento y propenso a errores si hay millones de filas
VBA básico (este artículo)	Repetitivo, datasets grandes	Automático, mantiene encabezado, ajusta bloque si se pasa	Requiere habilitar macros
VBA auto‑calibrado (pro)	Muy grandes/heterogéneos	Calcula tamaño por muestra y acierta mejor el “chunk”	Graba/borra un archivo temporal para estimar
Terceros (add‑ins/apps)	Sin tocar código	Interfaces cómodas, opciones por filas/hojas/valores	Pago/licencia en varios casos

Opción rápida (manual, sin programar)

Abre el archivo y decide cómo dividir (por filas, por columnas o por hojas).
Selecciona un bloque de datos (ej.: 100–50 000 filas, según lo “pesado” de tus datos) y copia con Ctrl+C.
Ve a Archivo > Libro nuevo y pega con Ctrl+V. Mantén la fila 1 como encabezado.
Guarda como .xlsx y revisa el tamaño del archivo.

Si supera 5 MB, pega menos filas/columnas y vuelve a guardar.
Repite hasta cubrir todo el dataset.

Opción automática (VBA, recomendado si lo harás a menudo)

Este macro divide la hoja activa en varios archivos .xlsx de hasta ~5 MB. Mantiene la primera fila como encabezado, empieza con bloques generosos y reduce automáticamente si se pasa del límite.

Cómo usarlo

Haz una copia de tu libro (trabaja siempre con copia).
Abre Excel → Alt+F11 → Insertar > Módulo.
Pega el siguiente código y pulsa F5 para ejecutarlo.
Si quieres, ajusta la carpeta de salida y el tamaño objetivo (comentado en el código).

Option Explicit

Sub DividirHojaPorTamano()
    Const LIMITE_MB As Double = 5#
    Const FILAS_MIN As Long = 50
    Dim CARPETA_SALIDA As String
    CARPETA_SALIDA = Environ$("USERPROFILE") & "\Desktop\ExcelSplit\"

    Dim ws As Worksheet: Set ws = ActiveSheet
    Dim ultFila As Long, ultCol As Long
    ultFila = ws.Cells(ws.Rows.Count, 1).End(xlUp).Row
    ultCol = ws.Cells(1, ws.Columns.Count).End(xlToLeft).Column
    If ultFila &lt; 2 Then MsgBox "No hay datos debajo del encabezado.": Exit Sub

    AsegurarCarpeta CARPETA_SALIDA

    Application.ScreenUpdating = False
    Application.DisplayAlerts = False

    Dim filaIni As Long: filaIni = 2  ' Fila 1 = encabezado
    Dim idx As Long: idx = 1
    Dim filasBloque As Long: filasBloque = 5000 ' Estimación inicial
    Dim probarFilas As Long, tamMB As Double
    Dim wbNuevo As Workbook, rng As Range, cab As Range, nombre As String

    Set cab = ws.Range(ws.Cells(1, 1), ws.Cells(1, ultCol))

    Do While filaIni &lt;= ultFila
        probarFilas = filasBloque
        If (filaIni + probarFilas - 1) &gt; ultFila Then probarFilas = ultFila - filaIni + 1

Reintentar:
        Set wbNuevo = Workbooks.Add(xlWBATWorksheet)
        cab.Copy: wbNuevo.Worksheets(1).Range("A1").PasteSpecial xlPasteAll
        Set rng = ws.Range(ws.Cells(filaIni, 1), ws.Cells(filaIni + probarFilas - 1, ultCol))
        rng.Copy: wbNuevo.Worksheets(1).Range("A2").PasteSpecial xlPasteAll
        Application.CutCopyMode = False

        ' Reducir tamaño: convertir fórmulas a valores
        wbNuevo.Worksheets(1).UsedRange.Value = wbNuevo.Worksheets(1).UsedRange.Value

        nombre = CARPETASALIDA & "parte" & Format(idx, "000") & ".xlsx"
        wbNuevo.SaveAs Filename:=nombre, FileFormat:=xlOpenXMLWorkbook
        tamMB = FileLen(nombre) / 1024# / 1024#

        If tamMB &gt; LIMITE_MB Then
            wbNuevo.Close SaveChanges:=False
            If Len(Dir$(nombre)) &gt; 0 Then Kill nombre
            If probarFilas &gt; FILAS_MIN Then
                probarFilas = Application.WorksheetFunction.Max(FILAS_MIN, Int(probarFilas * 0.7))
                GoTo Reintentar
            Else
                Application.DisplayAlerts = True: Application.ScreenUpdating = True
                MsgBox "Incluso con " & FILASMIN & " filas, el archivo supera " & LIMITEMB & " MB. " & _
                       "Elimina/Comprime imágenes o formato pesado, o divide por columnas/hojas.", vbExclamation
                Exit Sub
            End If
        Else
            wbNuevo.Close SaveChanges:=False
            filaIni = filaIni + probarFilas
            idx = idx + 1
        End If
    Loop

    Application.DisplayAlerts = True
    Application.ScreenUpdating = True
    MsgBox "Listo. Archivos creados en: " & CARPETA_SALIDA, vbInformation
End Sub

Private Sub AsegurarCarpeta(ByVal ruta As String)
    Dim partes() As String, p As String, i As Long
    If Right$(ruta, 1) &lt;&gt; "\" Then ruta = ruta & "\"
    partes = Split(ruta, "\"): p = partes(0) & "\"
    For i = 1 To UBound(partes)
        If partes(i) &lt;&gt; "" Then
            p = p & partes(i) & "\"
            If Dir(p, vbDirectory) = "" Then MkDir p
        End If
    Next i
End Sub

Qué hace y por qué funciona

Encabezado fijo: copia la fila 1 a cada archivo.
Ajuste dinámico: si el tamaño supera 5 MB, reduce el número de filas (chunk) y reintenta.
Archivos limpios: convierte fórmulas a valores para disminuir el peso.
Salida organizada: crea parte001.xlsx, parte002.xlsx, etc., en la carpeta elegida.

Parámetros que puedes ajustar

LIMITE_MB: cambia el objetivo de 5 a 2, 10, etc.
filasBloque: bloque inicial (5000). Sube si son datos “ligeros” (numéricos sin formatos), baja si hay muchas columnas, formatos o imágenes.
FILAS_MIN: mínimo permitido si ya estás al límite.
CARPETA_SALIDA: por defecto escribe en Escritorio\ExcelSplit (Windows). En Mac, usa Environ$("HOME") & "/Desktop/ExcelSplit/" y cambia la rutina AsegurarCarpeta por la versión “flex” que verás más abajo.

Versión avanzada: auto‑calibración por muestra (más precisa)

Si tus datos son heterogéneos (unas zonas con fórmulas/formatos pesados y otras no), la siguiente variante mide el tamaño real de una muestra y calcula automáticamente cuántas filas caben en ~5 MB. Luego aplica el mismo mecanismo de reducción si alguna parte se pasa.

Option Explicit

Sub DividirHojaPorTamano_Auto()
    Const LIMITE_MB As Double = 5#
    Const FILAS_MIN As Long = 50
    Const FILAS_MUESTRA As Long = 2000

    Dim CARPETA_SALIDA As String
    CARPETA_SALIDA = Environ$("USERPROFILE") & "\Desktop\ExcelSplit\"

    Dim ws As Worksheet: Set ws = ActiveSheet
    Dim ultFila As Long, ultCol As Long
    ultFila = ws.Cells(ws.Rows.Count, 1).End(xlUp).Row
    ultCol = ws.Cells(1, ws.Columns.Count).End(xlToLeft).Column
    If ultFila &lt; 2 Then MsgBox "No hay datos debajo del encabezado.": Exit Sub

    AsegurarCarpetaFlex CARPETA_SALIDA

    Dim calc As XlCalculation: calc = Application.Calculation
    Application.ScreenUpdating = False
    Application.DisplayAlerts = False
    Application.Calculation = xlCalculationManual

    Dim filasBloque As Long
    filasBloque = EstimarFilasPorLimite(ws, ultCol, FILASMUESTRA, LIMITEMB, FILAS_MIN)

    Dim filaIni As Long: filaIni = 2
    Dim idx As Long: idx = 1
    Dim probarFilas As Long, tamMB As Double
    Dim wbNuevo As Workbook, rng As Range, cab As Range, nombre As String

    Set cab = ws.Range(ws.Cells(1, 1), ws.Cells(1, ultCol))

    Do While filaIni &lt;= ultFila
        probarFilas = filasBloque
        If (filaIni + probarFilas - 1) &gt; ultFila Then probarFilas = ultFila - filaIni + 1

Reintentar:
        Set wbNuevo = Workbooks.Add(xlWBATWorksheet)
        cab.Copy wbNuevo.Worksheets(1).Range("A1")
        Set rng = ws.Range(ws.Cells(filaIni, 1), ws.Cells(filaIni + probarFilas - 1, ultCol))
        rng.Copy wbNuevo.Worksheets(1).Range("A2")

        ' Opcional: elimina objetos/imagenes para aligerar
        'Dim shp As Shape: For Each shp In wbNuevo.Worksheets(1).Shapes: shp.Delete: Next

        With wbNuevo.Worksheets(1).UsedRange
            .Value = .Value
        End With

        nombre = CARPETASALIDA & "parte" & Format(idx, "000") & ".xlsx"
        wbNuevo.SaveAs Filename:=nombre, FileFormat:=xlOpenXMLWorkbook
        tamMB = FileLen(nombre) / 1024# / 1024#

        If tamMB &gt; LIMITE_MB Then
            wbNuevo.Close False
            If Len(Dir$(nombre)) &gt; 0 Then Kill nombre
            If probarFilas &gt; FILAS_MIN Then
                probarFilas = Application.WorksheetFunction.Max(FILAS_MIN, Int(probarFilas * 0.8))
                GoTo Reintentar
            Else
                Application.Calculation = calc
                Application.DisplayAlerts = True
                Application.ScreenUpdating = True
                MsgBox "Incluso con " & FILASMIN & " filas, el archivo supera " & LIMITEMB & " MB. Revisa imágenes/formato.", vbExclamation
                Exit Sub
            End If
        Else
            wbNuevo.Close False
            filaIni = filaIni + probarFilas
            idx = idx + 1
        End If
    Loop

    Application.Calculation = calc
    Application.DisplayAlerts = True
    Application.ScreenUpdating = True
    MsgBox "Listo. Archivos creados en: " & CARPETA_SALIDA, vbInformation
End Sub

Private Function EstimarFilasPorLimite(ws As Worksheet, ultCol As Long, filasMuestra As Long, limiteMB As Double, filasMin As Long) As Long
    Dim totalFilas As Long: totalFilas = ws.Cells(ws.Rows.Count, 1).End(xlUp).Row - 1
    If totalFilas &lt;= 0 Then EstimarFilasPorLimite = filasMin: Exit Function

    Dim n As Long: n = Application.WorksheetFunction.Min(totalFilas, filasMuestra)
    Dim wb As Workbook, nombre As String, tamMB As Double

    Set wb = Workbooks.Add(xlWBATWorksheet)
    ws.Range(ws.Cells(1, 1), ws.Cells(1, ultCol)).Copy wb.Worksheets(1).Range("A1")
    ws.Range(ws.Cells(2, 1), ws.Cells(1 + n, ultCol)).Copy wb.Worksheets(1).Range("A2")
    wb.Worksheets(1).UsedRange.Value = wb.Worksheets(1).UsedRange.Value

    nombre = Environ$("TEMP") & IIf(Right$(Environ$("TEMP"), 1) = "\", "", "\") & "_probe.xlsx"
    On Error Resume Next
    wb.SaveAs Filename:=nombre, FileFormat:=xlOpenXMLWorkbook
    On Error GoTo 0
    tamMB = 0
    If Len(Dir$(nombre)) &gt; 0 Then tamMB = FileLen(nombre) / 1024# / 1024#
    wb.Close False
    If Len(Dir$(nombre)) &gt; 0 Then Kill nombre

    If tamMB &lt;= 0 Then
        EstimarFilasPorLimite = Application.WorksheetFunction.Max(filasMin, 5000)
    Else
        Dim estimado As Double
        estimado = (limiteMB / tamMB)  n  0.9 ' margen de seguridad 10%
        EstimarFilasPorLimite = Application.WorksheetFunction.Max(filasMin, Int(estimado))
    End If
End Function

Private Sub AsegurarCarpetaFlex(ByVal ruta As String)
    Dim sep As String
    If InStr(ruta, "/") &gt; 0 Then
        sep = "/"
    ElseIf InStr(ruta, "\") &gt; 0 Then
        sep = "\"
    Else
        sep = Application.PathSeparator ' ":" en Mac, "\" en Windows
    End If

    Dim partes() As String, p As String, i As Long
    If Right$(ruta, 1) &lt;&gt; sep Then ruta = ruta & sep
    partes = Split(ruta, sep): p = partes(0) & sep
    For i = 1 To UBound(partes)
        If partes(i) &lt;&gt; "" Then
            p = p & partes(i) & sep
            On Error Resume Next
            MkDir p
            On Error GoTo 0
        End If
    Next i
End Sub

Notas: si usas Mac y tu ruta usa “/”, la rutina AsegurarCarpetaFlex lo detecta y crea las carpetas correctamente. Si tu entorno requiere el separador “:”, usa Application.PathSeparator al construir la ruta.

Variantes útiles (elige según tu caso)

Más liviano aún: solo valores y formatos básicos

Si no necesitas conservar formatos complejos, cambia el pegado a xlPasteValuesAndNumberFormats para reducir más el tamaño. Sustituye las líneas de pegado por:

cab.Copy: wbNuevo.Worksheets(1).Range("A1").PasteSpecial xlPasteValuesAndNumberFormats
rng.Copy: wbNuevo.Worksheets(1).Range("A2").PasteSpecial xlPasteValuesAndNumberFormats

Y, si quieres, elimina objetos:

Dim shp As Shape
For Each shp In wbNuevo.Worksheets(1).Shapes: shp.Delete: Next

Dividir por hojas (cada hoja a un archivo)

Si tu libro tiene varias hojas pesadas, esta macro crea un .xlsx por cada hoja. No asegura ≤ 5 MB por sí sola, pero sirve como primer corte.

Sub DividirLibroPorHojas()
    Dim sh As Worksheet, wb As Workbook, nombre As String
    Dim CARPETA_SALIDA As String
    CARPETA_SALIDA = Environ$("USERPROFILE") & "\Desktop\ExcelSplit\"
    AsegurarCarpetaFlex CARPETA_SALIDA```
Application.ScreenUpdating = False
Application.DisplayAlerts = False

For Each sh In ThisWorkbook.Worksheets
    Set wb = Workbooks.Add(xlWBATWorksheet)
    sh.UsedRange.Copy wb.Worksheets(1).Range("A1")
    wb.Worksheets(1).UsedRange.Value = wb.Worksheets(1).UsedRange.Value
    nombre = CARPETA_SALIDA & LimpiarNombre(sh.Name) & ".xlsx"
    wb.SaveAs Filename:=nombre, FileFormat:=xlOpenXMLWorkbook
    wb.Close False
Next sh

Application.DisplayAlerts = True
Application.ScreenUpdating = True
MsgBox "Listo. Revisa " & CARPETA_SALIDA
```
End Sub

Private Function LimpiarNombre(ByVal s As String) As String
Dim i As Long, ch As String, res As String
Dim ilegales As String: ilegales = "/:\*?""<>|"
For i = 1 To Len(s)
ch = Mid\$(s, i, 1)
If InStr(ilegales, ch) = 0 Then res = res + ch Else res = res + "\_"
Next
LimpiarNombre = Left\$(res, 200)
End Function

Dividir por valores de una columna

Usa Datos > Filtro avanzado para sacar la lista de valores únicos de una columna (por ejemplo, “Cliente” o “País”) y, para cada valor, filtra y copia a un libro nuevo. Si alguno sobrepasa 5 MB, vuelve a aplicar el macro de tamaño sobre ese archivo.

Opción con herramientas de terceros

Si prefieres no programar, hay complementos/aplicaciones que dividen libros o hojas en lotes (por ejemplo, “Kutools for Excel”, “Excel Splitter”). Suelen permitir partir por número de filas, por hojas o por valores de una columna. Verifica que admitan guardar en .xlsx y, si es posible, que conviertan fórmulas a valores para aligerar.

Sugerencias para mantener cada parte por debajo de 5 MB

Guarda en .xlsx (más ligero que .xls).
Comprime o elimina imágenes y objetos; evita imágenes embebidas muy grandes.
Reemplaza fórmulas por valores cuando ya no necesites recalcular.
Limpia formato condicional excesivo y estilos duplicados.
En tablas dinámicas, desmarca “Guardar datos de origen con el archivo” si no es imprescindible.
Evita rangos usados “inflados”: borra filas/columnas vacías sobrantes y pulsa Ctrl+Fin para comprobar el último celda real.
Quita conexiones no utilizadas y desmarca “Guardar contraseña/consulta” si no hace falta.

Factor que “engorda”	Impacto típico	Cómo mitigarlo
Imágenes/objetos embebidos	Muy alto	Comprimir/Eliminar; usa vínculos a imágenes externas si procede
Fórmulas volátiles y matrices	Medio–alto	Convertir a valores cuando cierres el lote
Formato condicional masivo	Medio	Reducir reglas; aplicar a rangos exactos
Pivot caches guardados	Medio	Desmarcar “Guardar datos de origen” si no es clave
Rango usado incorrecto	Bajo–medio	Limpiar filas/columnas vacías, guardar, reabrir

Control de calidad: verifica que no falte nada

Cuenta de filas: suma filas exportadas y compáralas con el total original (sin encabezado). Puedes insertar una columna auxiliar con =CONTARA(A2:A1048576) por bloque o usar Power Query para reasociar y contar.
Validación de columnas: confirma que todas las columnas esperadas llegan al archivo final y en el mismo orden.
Muestreo visual: abre la primera y la última parte; mira encabezados y algunas filas intermedias.
Revisión de tamaños: ordena los archivos por MB y asegúrate de que ninguno supere 5 MB; si alguno se acerca a 4,9–5,0, considera bajar el bloque inicial un poco.

Solución de problemas habituales

“Incluso con 50 filas, el archivo supera 5 MB”: hay imágenes/objetos, formatos excesivos o una tabla dinámica con datos guardados. Quita objetos (macro sugerida), comprime imágenes y desactiva el guardado de datos de origen en pivots.
Rutas en Mac: usa Environ("HOME") & "/Desktop/ExcelSplit/" y la rutina AsegurarCarpetaFlex del ejemplo avanzado. Evita mezclar “\” y “/” en la misma ruta.
Macros bloqueadas: guarda el libro que contiene la macro como .xlsm, habilita macros y, si hace falta, firma el VBA.
Se pega lento: cuando no necesites formatos, usa pegado de valores; además, el ejemplo avanzado pone cálculo manual mientras corre.
Columnas con fórmulas que referencian otras hojas: al convertir a valores perderás el vínculo, lo cual es deseable en los “lotes” finales para reducir peso. Mantén una copia maestra con fórmulas.

Checklist antes de ejecutar

Haz copia del libro original.
Define si dividirás por filas, por hojas o por categorías (columna clave) y en qué orden.
Decide tu carpeta de salida y verifica permisos.
Si el archivo contiene imágenes: evalúa comprimirlas antes.

Consejos SEO‑técnicos y de mantenimiento

Usa nombres descriptivos en las partes (ej.: ventas2025parte_001.xlsx) para que se indexen y se entiendan fuera de contexto.
Incluye la fecha de corte o rango de filas en una hoja “README” si el destinatario no controla el orden.
Automatiza la tarea colocándola en tu Libro de macros personal para tenerla disponible en cualquier archivo.

Conclusión

Con el método manual puedes salir del paso en minutos, y con el VBA de este artículo tendrás un proceso repetible y seguro para dividir cualquier hoja en archivos ≤ 5 MB. Si el límite se te resiste, ataca las causas del tamaño (imágenes, formatos, pivots) y, si trabajas con muchos libros, la versión auto‑calibrada te ahorrará tiempo y prueba‑error.

Con estas opciones podrás dividir el libro en archivos que cumplan el límite de 5 MB sin depender de quién haya respondido originalmente ni de detalles adicionales.

Dividir un archivo de Excel grande en varios de ≤ 5 MB (manual, VBA y trucos de optimización)