MENU
  1. Início
  2. MS Office
  3. Excel
  4. Dividir arquivo Excel grande em partes menores até 5 MB (VBA, Python e PowerShell)

Dividir arquivo Excel grande em partes menores até 5 MB (VBA, Python e PowerShell)

Excel

Precisa dividir uma pasta de trabalho do Excel para respeitar um limite de envio de até 5 MB? Veja como fracionar com segurança: opções manuais, macro em VBA, Power Query, Python e PowerShell, além de truques para reduzir o tamanho antes de cortar o arquivo.

Índice

Visão geral e objetivos

Quando um .xlsx passa do limite de upload, a estratégia mais simples é separar o conteúdo em pedaços menores. O ideal é que cada parte fique abaixo do limite definido para anexos, portais ou integrações. Abaixo você encontra um guia prático, direto ao ponto, com três rotas principais:

  • Procedimento manual: copiar e colar em novos livros.
  • Automação com VBA: macro que salva partes automaticamente respeitando o tamanho máximo.
  • Ferramentas externas: complementos e utilitários que fazem a divisão por tamanho, linhas ou abas.

Também adicionamos alternativas modernas (Power Query, Power Automate, Python e PowerShell), além de boas práticas para manter consistência, reprodutibilidade e qualidade de dados.

Checklist antes de dividir

  • Backup: trabalhe em uma cópia do arquivo original.
  • Limpeza: remova imagens desnecessárias, formatação condicional excessiva, estilos órfãos, objetos e intervalos nomeados quebrados.
  • Formato: avalie salvar como .xlsb quando possível — costuma reduzir tamanho sem perda de funcionalidade.
  • Critério de particionamento: por aba, por intervalo de linhas, por período (mês), por cliente ou por qualquer chave de negócio que preserve o contexto lógico.
  • Padronização de nomes: defina previamente um padrão (ex.: Relatorio2025parte001.xlsx).

Procedimento manual

Quando usar

Funciona bem em livros com poucas abas ou tabelas não muito extensas, quando não compensa configurar automações.

Passo a passo

  1. Abra o arquivo e identifique blocos que devem permanecer juntos (uma aba por mês, um intervalo de linhas por região etc.).
  2. Selecione o bloco desejado e copie com Ctrl+C.
  3. Crie um novo livro (Arquivo > Novo), cole com Ctrl+V. Se quiser minimizar o tamanho, use Colar Especial > Valores.
  4. Salve com um nome consistente. Repita até segmentar todo o conteúdo.

Prós e contras

MétodoVantagensDesvantagens
ManualZero código, serve em qualquer ambiente.Lento e sujeito a erro humano em livros grandes; exige conferência minuciosa.
VBARápido e reprodutível; controla tamanho por parte.Depende de macros e permissões; requer manutenção.
Ferramentas externasInterface gráfica, vários critérios de corte.Podem ser pagas ou bloqueadas em ambientes corporativos.

Automação com vba

As macros abaixo atendem aos cenários mais comuns. A primeira salva cada aba em um arquivo isolado. A segunda fatia uma única tabela grande em múltiplos arquivos com controle de tamanho por parte.

Macro por aba

Crie um módulo no Editor do VBA, cole o código e execute. Cada aba com conteúdo vira um .xlsx na pasta de saída.

' VBA - salvar cada aba como um arquivo separado
Option Explicit

Private Function PickFolder() As String
On Error Resume Next
With Application.FileDialog(msoFileDialogFolderPicker)
.Title = "Selecione a pasta de saída"
If .Show = -1 Then PickFolder = .SelectedItems(1)
End With
If Len(PickFolder) = 0 Then PickFolder = ThisWorkbook.Path
End Function

Private Function SafeName(ByVal s As String) As String
Dim bad As Variant, i As Long
bad = Array("", "/", ":", "\*", "?", """", "<", ">", "|")
For i = LBound(bad) To UBound(bad)
s = Replace\$(s, bad(i), "\_")
Next
SafeName = s
End Function

Public Sub SalvarCadaAbaEmArquivos()
Dim outFolder As String, ws As Worksheet, base As String, outPath As String
Dim newWb As Workbook, srcWb As Workbook
Set srcWb = ActiveWorkbook
```
outFolder = PickFolder()
Application.ScreenUpdating = False
Application.DisplayAlerts = False

For Each ws In srcWb.Worksheets
    If WorksheetFunction.CountA(ws.UsedRange) &gt; 0 Then
        ws.Copy ' copia a aba para um novo workbook
        Set newWb = ActiveWorkbook
        base = SafeName(Left$(srcWb.Name, InStrRev(srcWb.Name, ".") - 1) &amp; "_" &amp; ws.Name)
        outPath = outFolder &amp; Application.PathSeparator &amp; base &amp; ".xlsx"
        newWb.SaveAs Filename:=outPath, FileFormat:=xlOpenXMLWorkbook
        newWb.Close SaveChanges:=False
    End If
Next ws

Application.DisplayAlerts = True
Application.ScreenUpdating = True
MsgBox "Concluído."
```
End Sub

Macro com limite de tamanho

Esta rotina pega uma tabela em uma única aba, duplica o cabeçalho em cada parte e usa um teste de salvamento temporário para garantir que cada arquivo fique abaixo do limite desejado. A quantidade de linhas por parte é ajustada automaticamente.

' VBA - dividir por linhas respeitando tamanho máximo por arquivo
Option Explicit

Private Function PickFolder() As String
On Error Resume Next
With Application.FileDialog(msoFileDialogFolderPicker)
.Title = "Selecione a pasta de saída"
If .Show = -1 Then PickFolder = .SelectedItems(1)
End With
If Len(PickFolder) = 0 Then PickFolder = ThisWorkbook.Path
End Function

Private Function SafeName(ByVal s As String) As String
Dim bad As Variant, i As Long
bad = Array("", "/", ":", "\*", "?", """", "<", ">", "|")
For i = LBound(bad) To UBound(bad)
s = Replace\$(s, bad(i), "\_")
Next
SafeName = s
End Function

Private Function TestSizeMB(ws As Worksheet, startRow As Long, endRow As Long, lastCol As Long, headerRows As Long) As Double
Dim wb As Workbook, t As Worksheet, tempFile As String, bytes As Double, tmpPath As String
tmpPath = Environ\$("TEMP")
If Len(Dir(tmpPath, vbDirectory)) = 0 Then tmpPath = ThisWorkbook.Path
```
Set wb = Workbooks.Add(xlWBATWorksheet)
Set t = wb.Sheets(1)

' cabeçalho
ws.Range(ws.Cells(1, 1), ws.Cells(headerRows, lastCol)).Copy
t.Range("A1").PasteSpecial xlPasteValues

' dados
ws.Range(ws.Cells(startRow, 1), ws.Cells(endRow, lastCol)).Copy
t.Cells(headerRows + 1, 1).PasteSpecial xlPasteValues

tempFile = tmpPath &amp; Application.PathSeparator &amp; "tmp_split_" &amp; Format(Timer, "0") &amp; "_" &amp; CStr(Int(Rnd() * 100000)) &amp; ".xlsx"
wb.SaveAs Filename:=tempFile, FileFormat:=xlOpenXMLWorkbook
bytes = FileLen(tempFile)
wb.Close SaveChanges:=False
On Error Resume Next
Kill tempFile
On Error GoTo 0

TestSizeMB = bytes / 1024# / 1024#
```
End Function

Private Sub SaveChunk(ws As Worksheet, startRow As Long, endRow As Long, lastCol As Long, headerRows As Long, outFolder As String, part As Long)
Dim wb As Workbook, t As Worksheet, base As String, outPath As String
Set wb = Workbooks.Add(xlWBATWorksheet)
Set t = wb.Sheets(1)
```
' cabeçalho
ws.Range(ws.Cells(1, 1), ws.Cells(headerRows, lastCol)).Copy
t.Range("A1").PasteSpecial xlPasteValues

' dados
ws.Range(ws.Cells(startRow, 1), ws.Cells(endRow, lastCol)).Copy
t.Cells(headerRows + 1, 1).PasteSpecial xlPasteValues

base = SafeName(Left$(ws.Parent.Name, InStrRev(ws.Parent.Name, ".") - 1) &amp; "_" &amp; ws.Name)
outPath = outFolder &amp; Application.PathSeparator &amp; base &amp; "_parte_" &amp; Format$(part, "000") &amp; ".xlsx"
wb.SaveAs Filename:=outPath, FileFormat:=xlOpenXMLWorkbook
wb.Close SaveChanges:=False
```
End Sub

Public Sub DividirPorLinhasComLimite()
Dim ws As Worksheet
Dim headerRows As Long, safeLimitMB As Double, minRows As Long, guessRows As Long
Dim lastRow As Long, lastCol As Long, firstData As Long
Dim r As Long, part As Long, outFolder As String
```
' parâmetros ajustáveis
Set ws = ActiveSheet                 ' escolha a aba com a sua tabela
headerRows = 1                        ' número de linhas de cabeçalho
safeLimitMB = 4.8                     ' margem de segurança abaixo do limite real
minRows = 200                         ' garante progresso mesmo em linhas "pesadas"
guessRows = 50000                     ' palpite inicial por parte

lastRow = ws.Cells(ws.Rows.Count, 1).End(xlUp).Row
lastCol = ws.Cells(1, ws.Columns.Count).End(xlToLeft).Column
firstData = headerRows + 1
outFolder = PickFolder()

Application.ScreenUpdating = False
Application.DisplayAlerts = False
Application.Calculation = xlCalculationManual

r = firstData: part = 1
Do While r &lt;= lastRow
    Dim rowsLeft As Long, hi As Long, lo As Long, mid As Long, best As Long, sizeMB As Double
    rowsLeft = lastRow - r + 1
    hi = IIf(rowsLeft &lt; guessRows, rowsLeft, guessRows)
    lo = minRows
    best = lo

    ' busca binária para achar o maior bloco que cabe
    Do While lo &lt;= hi
        mid = (lo + hi) \ 2
        sizeMB = TestSizeMB(ws, r, r + mid - 1, lastCol, headerRows)
        If sizeMB &lt;= safeLimitMB Then
            best = mid
            lo = mid + 1
        Else
            hi = mid - 1
        End If
        DoEvents
    Loop

    ' salva a parte
    SaveChunk ws, r, r + best - 1, lastCol, headerRows, outFolder, part
    r = r + best
    part = part + 1
Loop

Application.Calculation = xlCalculationAutomatic
Application.DisplayAlerts = True
Application.ScreenUpdating = True
MsgBox "Divisão concluída."
```
End Sub

Boas práticas ao rodar a macro

  • Feche outros arquivos para liberar memória.
  • Se o livro tem muitas fórmulas voláteis, considere colar valores antes da divisão (em uma cópia).
  • Prefira saída como .xlsx. Use .xlsb quando a redução de tamanho for determinante.

Automação sem macro

Power Query

  1. Selecione a sua tabela e escolha Dados > Obter e Transformar para abrir o editor do Power Query.
  2. Adicione uma coluna de índice e crie uma coluna de grupo: por exemplo, agrupe a cada n linhas (índice dividido por n).
  3. Duplique a consulta e filtre cada grupo. Carregue cada grupo em planilhas separadas.
  4. Salve cada planilha como um arquivo independente. Para automação contínua, combine com um fluxo no Power Automate.

Vantagem: consultas reproduzíveis e sem VBA. Ótimo para lotes por quantidade de linhas ou por regra de negócio.

Power Automate

Crie um fluxo que leia uma tabela do OneDrive ou SharePoint, aplique filtro/paginação e gere arquivos menores. É prático para cenários recorrentes e integrações com sistemas externos.

Scripts externos

Python com pandas

Para cenários de servidor, pandas oferece velocidade e controle fino. O exemplo abaixo divide uma planilha grande; cada parte é salva somente quando o arquivo de teste fica dentro do limite definido.

# Python 3.x
pip install pandas openpyxl XlsxWriter
import os, math, tempfile, uuid
import pandas as pd

fonte = r"C:\dados\arquivo.xlsx"
aba = "Dados"
destino = r"C:\dados\saida"
alvo\_mb = 5.0
seguro\_mb = 4.8
min\_linhas = 200
palpite = 50000

os.makedirs(destino, exist\_ok=True)
df = pd.read\excel(fonte, sheet\name=aba)

def tamanho\temp\mb(df\_slice):
tmp = os.path.join(tempfile.gettempdir(), f"tmp\_{uuid.uuid4().hex}.xlsx")
with pd.ExcelWriter(tmp, engine="xlsxwriter") as w:
df\slice.to\excel(w, index=False, sheet\_name="Dados")
size = os.path.getsize(tmp) / (1024 \* 1024)
os.remove(tmp)
return size

i = 0
parte = 1
base = os.path.splitext(os.path.basename(fonte))\[0] + "\_" + aba
while i < len(df):
hi = min(palpite, len(df) - i)
lo = min\_linhas
melhor = lo
while lo <= hi:
mid = (lo + hi) // 2
fatia = df.iloc\[i\:i+mid]
mb = tamanho\temp\mb(fatia)
if mb <= seguro\_mb:
melhor = mid
lo = mid + 1
else:
hi = mid - 1
saida = os.path.join(destino, f"{base}parte{parte:03}.xlsx")
with pd.ExcelWriter(saida, engine="xlsxwriter") as w:
df.iloc\[i\:i+melhor].to\excel(w, index=False, sheet\name="Dados")
i += melhor
parte += 1
print("Concluído.") </code></pre>

<p>Dica: se o conjunto é apenas dados tabulares, exportar para <em>.csv</em> reduz o tamanho e acelera o processo. Basta trocar o escritor por <code>to_csv</code> e ajustar a verificação de tamanho com <code>os.path.getsize</code>.</p>

<h3>PowerShell</h3>
<p>Em máquinas Windows, é possível automatizar via COM do Excel. O exemplo a seguir divide uma aba em blocos, ajustando dinamicamente o tamanho do lote ao detectar que o arquivo ficou acima do limite de segurança.</p>
<pre><code># PowerShell
$fonte     = "C:\dados\arquivo.xlsx"
$aba       = "Dados"
$destino   = "C:\dados\saida"
$seguroMB  = 4.8
$minLinhas = 200
$palpite   = 50000

New-Item -ItemType Directory -Force -Path \$destino | Out-Null

\$excel = New-Object -ComObject Excel.Application
\$excel.Visible = \$false
\$wb = \$excel.Workbooks.Open(\$fonte)
\$ws = \$wb.Worksheets.Item(\$aba)

\$lastRow = \$ws.UsedRange.Rows.Count
\$lastCol = \$ws.UsedRange.Columns.Count
\$header  = 1
\$row     = \$header + 1
\$parte   = 1
\$base    = \[IO.Path]::GetFileNameWithoutExtension(\$fonte) + "\_" + \$aba

function Salvar-Parte(\[int]\$start, \[int]\$finish, \[int]\$parteNum) {
param()
\$novo = \$excel.Workbooks.Add()
\$alvo = \$novo.Worksheets.Item(1)
```
$ws.Range($ws.Cells(1,1), $ws.Cells($header, $lastCol)).Copy()
$alvo.Range("A1").PasteSpecial(-4163) # xlPasteValues

$ws.Range($ws.Cells($start,1), $ws.Cells($finish, $lastCol)).Copy()
$alvo.Range(("A{0}" -f ($header + 1))).PasteSpecial(-4163)

$out = Join-Path $destino ("{0}_parte_{1:d3}.xlsx" -f $base, $parteNum)
$novo.SaveAs($out, 51) # 51 = xlOpenXMLWorkbook (.xlsx)
$tam = (Get-Item $out).Length / 1MB
$novo.Close($false)
return @{ Path = $out; MB = [math]::Round($tam,2) }
```
}

while (\$row -le \$lastRow) {
\$resto = \$lastRow - \$row + 1
\$hi = \[Math]::Min(\$palpite, \$resto)
\$lo = \$minLinhas
\$melhor = \$lo
```
while ($lo -le $hi) {
    $mid = [Math]::Floor(($lo + $hi) / 2)
    $temp = Salvar-Parte -start $row -finish ($row + $mid - 1) -parteNum 999
    Remove-Item $temp.Path -Force
    if ($temp.MB -le $seguroMB) { $melhor = $mid; $lo = $mid + 1 } else { $hi = $mid - 1 }
}

$final = Salvar-Parte -start $row -finish ($row + $melhor - 1) -parteNum $parte
Write-Host ("Parte {0} salva ({1} MB)" -f $parte, $final.MB)
$row += $melhor
$parte++
```
}

\$wb.Close(\$false)
\$excel.Quit()
\[System.Runtime.Interopservices.Marshal]::ReleaseComObject(\$ws) | Out-Null
\[System.Runtime.Interopservices.Marshal]::ReleaseComObject(\$wb) | Out-Null
\[System.Runtime.Interopservices.Marshal]::ReleaseComObject(\$excel) | Out-Null </code></pre>

<h2>Ferramentas especializadas</h2>
<p>Complementos como <em>Kutools for Excel</em> e utilitários do tipo <em>Excel Splitter</em> oferecem assistentes com critérios de divisão por tamanho, número de linhas, colunas ou abas. Vantagens: interface gráfica e rapidez. Desvantagens: custo de licença e possíveis restrições de instalação em empresas. Em ambientes auditados, valide permissões com TI antes da instalação.</p>

<h2>Estratégias de redução de tamanho</h2>
<ul>
  <li><strong>Salvar como binário</strong>: <em>Arquivo &gt; Salvar como &gt; .xlsb</em> costuma trazer boa economia.</li>
  <li><strong>Limpar estilos</strong>: estilos personalizados acumulados incham o arquivo. Macro útil:
    <pre><code>Sub LimparEstilos()
    Dim s As Style
    For Each s In ActiveWorkbook.Styles
        If Not s.BuiltIn Then On Error Resume Next: s.Delete: On Error GoTo 0
    Next s
End Sub
</code></pre>
  </li>
  <li><strong>Reduzir formatação condicional</strong>: combine regras redundantes e aplique em intervalos corretos.</li>
  <li><strong>Compactar imagens</strong>: use a compressão nativa das imagens ou remova-as se não forem necessárias para os dados.</li>
  <li><strong>Remover objetos</strong> em massa:
    <pre><code>Sub RemoverObjetos()
    Dim sh As Shape, ws As Worksheet
    For Each ws In ActiveWorkbook.Worksheets
        For Each sh In ws.Shapes
            sh.Delete
        Next sh
    Next ws
End Sub

Converter fórmulas em valores em abas que não precisam recalcular.
Tabelas dinâmicas: desmarque “Salvar dados de origem com o arquivo” quando possível.

Padrões de nomeação e auditoria

Use um padrão que preserve a ordenação natural e o contexto de negócio. Exemplos:

  • Vendas2025parte001.xlsx, Vendas2025parte002.xlsx…
  • FaturamentoregiaoSul.xlsx, FaturamentoregiaoNorte.xlsx

Depois de dividir, valide a integridade:

  • Contagem de linhas: some as linhas das partes e compare com o original.
  • Totais de negócio: confira somatórios-chave (receita, quantidade, custo).
  • Chaves únicas: verifique duplicidade não esperada após a divisão.

Quadro de decisão

CenárioAbordagem recomendadaObservações
Dados tabulares muito longosPower Query para lotes por quantidade de linhas, ou macro VBA por linhas com limite de tamanhoConsultas reproduzíveis e fáceis de manter
Integração com APIs ou jobsScript em Python ou PowerShell com verificação de tamanho por arquivoFlexível; roda em servidor; não depende do Excel instalado no caso de CSV
Tamanho inflado por formatação e mídiaLimpeza de estilos e objetos; salvar em binárioReduz número de partes a gerar
Necessidade apenas de envio por e‑mailCompactar em ZIPEvite dividir se a unidade lógica do conjunto for importante
Sem permissão para macrosPower Query, Power Automate ou ferramentas externas aprovadasEvita bloqueios por política de TI

Perguntas frequentes

Como estimar o tamanho por linha antes de dividir? Faça um teste salvando uma amostra de mil linhas em um arquivo temporário e meça o tamanho. Divida o limite desejado pela média por linha e aplique uma margem de segurança de cerca de dez por cento.

Posso manter fórmulas nas partes? Sim, mas fórmulas complexas deixam os arquivos maiores. Em relatórios estáticos, prefira valores colados.

O que fazer se a macro ficar lenta? Feche outros aplicativos, desligue a atualização de tela, aumente a memória disponível e salve em disco local em vez de rede durante o processo.

As partes precisam repetir o cabeçalho? Recomenda‑se sim, principalmente quando o destino são usuários ou sistemas que consomem cada arquivo isoladamente.

É seguro usar ferramentas de terceiros? Em casa, normalmente sim. Em empresas, verifique políticas de software, riscos de macro e compliance de dados.

Exemplos completos e verificações finais

  • Exemplo de política de nomes: ClienteXmovimento2025parte001.xlsx … parte_010.xlsx.
  • Planilha de controle: crie uma aba “Mapa” com a lista de partes geradas, intervalo de linhas coberto por cada uma e somatórios de validação.
  • Registro de execução: anote parâmetros usados (aba, linhas de cabeçalho, limite de tamanho, data de execução e responsável).

Conclusão

Para fracionar um livro do Excel respeitando um limite de tamanho, escolha a estratégia que melhor equilibra esforço e governança: manual para casos pontuais, VBA para alto volume com controle por arquivo e ferramentas externas ou scripts quando você precisa escalar, agendar ou integrar. Com as práticas de limpeza e validação apresentadas aqui, você mantém consistência de dados, auditabilidade e arquivos prontos para compartilhar ou carregar em qualquer sistema.

Excel
Excel Power Query PowerShell Python VBA
Índice