Por qué tu CSV es demasiado grande para Excel y qué hacer en su lugar (Guía 2026)

Diagnóstico en 30 segundos: cuenta las filas antes de culpar al archivo

Lo primero que hay que establecer cuando Excel se niega a abrir tu archivo CSV o lo recorta es cuántas filas tiene el archivo en realidad, porque la solución depende por completo de ese número, y adivinar hace perder el tiempo. Un archivo con 900,000 filas se abre bien en Excel y el problema es otro, como un delimitador o un problema de codificación, que cubren las guías complementarias. Un archivo con 1,200,000 filas choca con el límite de la cuadrícula, y ningún ajuste dentro de Excel hará que quepa. Cuenta primero y luego elige la solución que corresponde a ese número, en lugar de probar soluciones al azar.

El recuento más rápido no necesita ningún programa más allá de una terminal. En Windows, abre PowerShell y ejecuta Get-Content con Measure-Object, o en un Mac o en Linux ejecuta wc -l sobre el archivo, que cuenta los saltos de línea. Un editor de texto con un contador de líneas en la barra de estado también sirve, aunque un archivo muy grande puede tardar en abrirse en un editor. El número que obtienes son líneas, no filas de datos: un archivo con encabezado tiene una línea más que filas de datos, y los valores que contienen saltos de línea entre comillas pueden ocupar más de una línea, así que el recuento de líneas es un límite superior, no un recuento exacto de filas, y para la mayoría de las exportaciones es lo bastante exacto para decidir.

Para un recuento exacto, usa el módulo csv de Python, que lee el archivo fila a fila y nunca lo carga en memoria, así que funciona con archivos demasiado grandes para una hoja de cálculo. El fragmento de abajo contó un archivo de prueba de 1,200,000 filas de datos en un par de segundos y coincidió exactamente con el recuento de líneas, porque ese archivo no tenía saltos de línea entre comillas. Si los dos recuentos no coinciden en tu archivo, confía en el recuento del módulo csv: la diferencia son valores con saltos de línea incrustados, y también te dice que el archivo tiene valores multilínea entre comillas, algo que importa para la receta de división más adelante en esta guía.

Terminal (Mac or Linux):
$ wc -l big_sample.csv
1200001 big_sample.csv

PowerShell (Windows):
PS> (Get-Content big_sample.csv | Measure-Object -Line).Lines
1200001

Python (exact row count, one row at a time):
import csv
with open('big_sample.csv', newline='') as f:
    reader = csv.reader(f)
    header = next(reader)
    rows = sum(1 for _ in reader)
print(header, rows)
# ['id', 'name', 'total'] 1200000

Lines minus the header row: 1,200,001 - 1 = 1,200,000 data rows.
That is 151,425 rows over Excel's limit.

Fíjate en lo que prueba este archivo de prueba: un CSV de 1,200,000 filas con tres columnas cortas ocupa solo unos 32 MB en disco, así que el problema no es el tamaño del archivo en megabytes. La gente espera que un archivo grande signifique cientos de megabytes, pero un archivo estrecho con un millón de filas cortas es pequeño en disco y aun así demasiado grande para la cuadrícula. El recuento de filas es el número que importa, no los megabytes, y por eso el recuento es el primer paso. Si tu archivo supera las 1,048,575 filas de datos, tienes un problema de límite de la cuadrícula, y el resto de esta guía te sirve. Si está por debajo de ese número, el problema está en otro sitio, y las guías complementarias sobre el problema de la columna única, el problema de codificación y el problema de los ceros a la izquierda son los lugares donde buscar.

El número que importa: 1,048,576 filas

Excel admite como máximo 1,048,576 filas por 16,384 columnas en una hoja, y una sola celda admite como máximo 32,767 caracteres. Esos son los límites publicados para el formato de hoja de cálculo actual, y no han cambiado en años. La fila de encabezado cuenta como una de las 1,048,576, así que un archivo CSV con encabezado puede tener como máximo 1,048,575 filas de datos en una hoja. Un archivo con 1,048,576 filas de datos más un encabezado se pasa por una fila, y Excel lo recorta. El formato antiguo .xls es mucho más pequeño, con 65,536 filas por hoja, así que si tu archivo viene de un sistema antiguo, comprueba también el formato, pero para un archivo .csv abierto en un Excel moderno, 1,048,576 es el número.

El formato CSV en sí no fija ningún límite. Un archivo CSV es texto sin formato, con filas separadas por saltos de línea y valores separados por un delimitador, y la descripción del formato, la RFC 4180, no dice nada sobre un número máximo de filas, columnas o bytes. Un archivo CSV puede tener tantas filas como espacio tenga tu disco, y el archivo de prueba de esta guía tiene 1,200,000 filas en 32 MB sin ningún problema. El límite viene de lo que abre el archivo, nunca del archivo en sí, y por eso el mismo archivo se abre completo en un editor de texto o en una base de datos y se recorta en Excel. Culpar al archivo, o al programa que lo exportó, no da en el clavo: el exportador hizo su trabajo, y el lector es el que tiene el techo.

Hay otros dos números que dan forma al problema en la práctica. El primero es el número de columnas: 16,384 columnas es generoso, y casi ningún CSV real se acerca a esa cifra, así que las columnas rara vez son el límite que manda. El segundo es la memoria: Excel carga en memoria las filas que muestra, y un archivo cerca del límite de filas con filas anchas puede hacer que el programa vaya muy lento o se cierre, incluso cuando el recuento de filas está técnicamente por debajo del límite. Un millón de filas de valores cortos se abre bien, mientras que un millón de filas de valores de texto largos puede no abrirse, así que trata 1,048,576 como el techo duro y unos cientos de miles de filas anchas como el techo práctico. Si tu archivo es lento además de grande, la receta de división de esta guía ayuda por partida doble, porque los archivos más pequeños son archivos más rápidos.

Qué hace Excel en realidad cuando el archivo es demasiado grande

Cuando abres un archivo CSV con más filas de las que admite la cuadrícula, Excel no rechaza el archivo. Carga las primeras 1,048,576 filas, incluido el encabezado, y te muestra un aviso de que el conjunto de datos es demasiado grande para la cuadrícula de Excel y de que guardar el libro perderá los datos que no se cargaron. La propia página de soporte de Microsoft lo expresa exactamente así en todos los idiomas: el conjunto de datos supera el número de filas disponibles en Excel, así que algunos datos no se cargaron. El resto de tus filas sigue en el archivo en disco, intacto, pero no está en el libro, y nada en pantalla te dice qué filas faltan salvo el recuento.

Lo silencioso es lo que hace esto peligroso. El libro parece completo: tiene un encabezado, tiene filas hasta el final de la hoja, y las filas que faltan simplemente no están, sin hueco y sin marca. Si ordenas, filtras o haces un gráfico con ese libro, trabajas con un conjunto de datos parcial y los resultados son erróneos de una forma difícil de detectar, porque el primer millón de filas suele parecer representativo. Los totales, los promedios y los recuentos calculados a partir del libro recortado quedan todos por debajo de lo real, y el error crece con cada fila que pasa del límite. Un archivo con 1,200,000 filas pierde en silencio alrededor de una octava parte de sus datos, y un archivo con 5 millones de filas pierde cuatro quintas partes, mientras en pantalla se ve exactamente igual.

La parte destructiva llega cuando guardas. Guardar el libro recortado escribe de vuelta solo las filas que cargó Excel, así que las filas que nunca llegaron a la cuadrícula desaparecen del archivo guardado para siempre. La guía complementaria sobre guardar cubre este viaje de ida y vuelta en detalle, pero la regla aquí es absoluta: nunca guardes encima del archivo CSV original desde un libro que te avisó sobre el límite de la cuadrícula. Si ya guardaste encima de la única copia, revisa el historial de versiones de OneDrive o SharePoint, una copia de seguridad, un archivo adjunto de correo o el sistema de origen del archivo, porque el archivo guardado ya no tiene las filas que faltan y ninguna fórmula puede devolverlas. Cierra el libro recortado sin guardar y empieza de nuevo desde el archivo original con una de las soluciones de abajo.

Los límites por aplicación: Excel, Sheets, LibreOffice y las herramientas sin límite

No todos los programas se detienen en el mismo punto, así que a veces la solución correcta empieza con otro programa. Excel se detiene en 1,048,576 filas por 16,384 columnas por hoja, como arriba. LibreOffice Calc se detiene en las mismas 1,048,576 filas, pero solo 1,024 columnas, así que tampoco ayuda con un archivo ancho. Apple Numbers avisa cuando un archivo supera alrededor de 1,000,000 de líneas, así que está en la misma clase. Google Sheets cuenta celdas en lugar de filas: una hoja de cálculo puede tener hasta 20 millones de celdas, y la importación de un CSV también tiene un tope de 100 MB, así que un archivo estrecho puede tener más filas de las que Excel permite, mientras que un archivo ancho tiene menos, y el límite exacto de filas depende de tu número de columnas. Un archivo de 10 columnas puede tener unas 2 millones de filas en Sheets, mientras que uno de 50 columnas tiene unas 400,000.

Los editores de texto no tienen límite de filas propio, solo la memoria de tu equipo, así que un CSV grande se abre completo en Notepad, TextEdit o VS Code como texto sin formato, y puedes buscar en él, leer las primeras y las últimas filas y revisar el encabezado, aunque no puedes ordenarlo ni filtrarlo como una hoja de cálculo. Eso hace que un editor de texto sea la herramienta adecuada para inspeccionar un archivo grande y la herramienta equivocada para analizarlo. Python y su módulo csv tampoco tienen límite de filas, solo memoria, y como el módulo csv lee una fila cada vez, puede contar, filtrar y dividir archivos mucho más grandes que cualquier hoja de cálculo, usando casi nada de memoria. La ruta de la base de datos no tiene límite práctico de filas: importa el CSV a SQLite, Postgres o incluso a una base de datos de escritorio, y un millón de filas es una tabla pequeña.

La regla práctica es ajustar la herramienta al trabajo, no forzar el archivo dentro de la herramienta que tienes abierta. Si necesitas mirar los datos, usa un editor de texto. Si necesitas filtrarlos o dividirlos, usa un script. Si necesitas analizarlos todos en una cuadrícula, usa la solución del Data Model de abajo, o una base de datos. Si solo necesitas un resumen, agrega el archivo con un script y abre el resumen pequeño en Excel. El archivo no es el problema, y la hoja de cálculo no está rota. El desajuste está entre un conjunto de datos de un millón de filas y una cuadrícula de un millón de filas, y la solución es dejar de pedirle a la cuadrícula que guarde más de lo que puede.

Solución 1: divide el archivo en partes que Excel pueda abrir

Dividir es la solución que conviene probar primero cuando necesitas los datos en hojas normales, porque es sencilla, no necesita nada más allá de Python, y cada parte se abre con normalidad en Excel con su encabezado intacto. La receta es leer el archivo fila a fila, escribir como máximo 1,048,575 filas de datos en cada parte, y repetir la línea de encabezado al principio de cada parte, de modo que cada parte sea un archivo CSV completo por sí sola. Usa 1,048,575 en lugar de 1,048,576, porque el encabezado cuenta como una fila, y una parte con 1,048,576 filas de datos más un encabezado se pasaría del límite otra vez por una fila. El script de abajo hace exactamente eso, usando solo la biblioteca estándar de Python, así que no hay nada que instalar.

El script se probó con el archivo de muestra de 1,200,000 filas de la sección de diagnóstico, que ocupa 32 MB en disco. Produjo dos partes: la primera tiene el encabezado más 1,048,575 filas de datos, exactamente 1,048,576 líneas, y la segunda tiene el encabezado más las 151,425 filas de datos restantes. Volver a unir las partes quitando el encabezado repetido de la segunda parte y concatenando produjo un archivo idéntico al original byte a byte, confirmado al comparar los valores hash de los archivos, así que la división no pierde nada ni cambia nada. Un archivo de 5 millones de filas se dividiría en cinco partes de la misma forma, y uno de 10 millones de filas en diez, sin límite superior salvo el espacio en disco.

Hay dos detalles que importan al dividir. Primero, mantén el encabezado en cada parte, porque una parte sin encabezado se abre con la primera fila de datos como encabezado, y los nombres de columna desaparecen. Segundo, nunca dividas el archivo abriéndolo en Excel y copiando filas a mano, porque la copia manual parte del libro recortado y las filas que pasan del límite ya faltan. Divide desde el archivo original en disco, con un script, antes de que Excel lo toque. Una vez que existen las partes, ábrelas de una en una, haz tu trabajo y guarda el archivo original aparte, porque las partes son copias de trabajo y el original es la única copia completa.

import csv

LIMIT = 1_048_575  # data rows per chunk (header counts as a row)

with open('big.csv', newline='') as f:
    reader = csv.reader(f)
    header = next(reader)
    chunk = 0
    count = 0
    out = open(f'chunk_{chunk}.csv', 'w', newline='')
    writer = csv.writer(out)
    writer.writerow(header)
    for row in reader:
        if count == LIMIT:
            out.close()
            chunk += 1
            count = 0
            out = open(f'chunk_{chunk}.csv', 'w', newline='')
            writer = csv.writer(out)
            writer.writerow(header)
        writer.writerow(row)
        count += 1
    out.close()

print(f'split into {chunk + 1} chunks')

# Verified on a 1,200,000-row file (32 MB):
# chunk_0.csv = 1,048,576 lines (header + 1,048,575 rows)
# chunk_1.csv = 151,426 lines (header + 151,425 rows)
# Rejoining the chunks (header stripped from chunk 1 onward)
# reproduced the original file byte-identically.

Otra ventaja de dividir merece una mención: las partes son archivos independientes, así que puedes pasar una parte a un colega, abrir una parte en un equipo lento, o procesar las partes en paralelo, y nada de eso es posible con un solo archivo que ninguna hoja de cálculo puede abrir. Si el archivo crece cada semana, guarda el script y ejecútalo con cada exportación nueva, en lugar de dividir a mano cada vez. Y si divides porque necesitas enviar los datos a algún sitio, recuerda que las partes son las copias de trabajo: el archivo original es el que hay que archivar, y las partes son las que hay que abrir.

Solución 2: carga todo el archivo en el Data Model con Power Query

Dividir funciona cuando necesitas hojas normales, pero a veces necesitas analizar todo el conjunto de datos a la vez, y para eso Excel tiene una segunda puerta: el Data Model. Power Query puede cargar un archivo CSV en el Data Model en lugar de en la cuadrícula, y el Data Model usa compresión y guarda decenas de millones de filas en memoria, muy por encima del límite de 1,048,576 filas de la cuadrícula. No puedes ver todas las filas en una hoja, porque el límite de la cuadrícula sigue valiendo para lo que se muestra, pero puedes construir tablas dinámicas y gráficos dinámicos sobre todo el conjunto de datos, y las agregaciones cuentan cada fila, incluidas las que la cuadrícula nunca podría mostrar. Esa es la solución correcta cuando la pregunta es un resumen, un total o una tabla dinámica, en lugar de una mirada fila a fila.

Los pasos, en Excel para Windows, son deliberadamente aburridos: abre un libro en blanco, ve a Datos, luego Obtener datos, luego Desde archivo, luego Desde texto/CSV, elige el archivo, y en la vista previa elige Cargar en, luego selecciona Solo crear conexión y marca Agregar estos datos al modelo de datos, en lugar de cargar en una tabla. Luego crea una tabla dinámica desde el Data Model, y la tabla dinámica lee todo el conjunto de datos. La guía documentada de Microsoft para conjuntos de datos demasiado grandes para la cuadrícula describe exactamente esta ruta, y también advierte, otra vez, que no guardes encima del archivo original, porque la cuadrícula sigue teniendo solo las primeras filas si cargas en una tabla por error.

Aquí van dos advertencias, dichas con claridad. La primera es que la ruta del Data Model necesita Excel para Windows con Power Query, y Excel para Mac tiene un soporte limitado para crear y usar Data Models, así que los usuarios de Mac pueden necesitar ejecutar Windows, o usar la receta de división. La segunda es que una tabla dinámica sobre el Data Model responde preguntas agregadas, no preguntas de filas: puedes sumar, contar y agrupar todo el archivo, pero no puedes desplazarte hasta la fila 3,000,000 en una hoja, porque la hoja sigue deteniéndose en 1,048,576. Si necesitas ver filas concretas más allá del límite, divide el archivo. Si necesitas totales sobre todas ellas, usa el Data Model.

Solución 3: mira solo las filas que necesitas

La mayoría de las veces, nadie necesita en realidad el millón de filas en pantalla a la vez. Necesitas las filas de un cliente, un mes, una región o un código de error, y el resto del archivo es contexto que nunca vas a leer. Filtrar el archivo hasta dejar solo lo que necesitas antes de abrirlo es más rápido que dividirlo, y produce un archivo pequeño que se abre con normalidad en Excel, sin partes que gestionar. El filtro se ejecuta en un script que lee una fila cada vez, así que funciona con archivos de cualquier tamaño, y el resultado es un archivo CSV completo con su propio encabezado, listo para abrir.

La receta de abajo usa solo la biblioteca estándar de Python, y se probó con el mismo archivo de muestra de 1,200,000 filas: quedarse solo con las filas en las que la columna total es mayor que 90 produjo un archivo de 74,227 líneas, con 74,226 filas de datos, en unos dos segundos, y la primera fila conservada es la que cabría esperar, la fila en la que el total supera 90 por primera vez. Cambia la condición para que coincida con tu propia pregunta, un rango de fechas, un nombre de cliente, un valor de estado, y el resultado es el trozo del archivo que necesitas de verdad. El mismo patrón sirve para las primeras N filas, con un comando head o un contador que se detiene tras N filas, y para las últimas N filas, con un comando tail, cuando solo necesitas comprobar cómo termina un archivo.

Filtrar también responde a la pregunta de si merece la pena abrir el archivo. Cuenta primero las filas que coinciden con tu condición, y si el recuento es pequeño, abre el archivo filtrado. Si el recuento sigue por encima del límite de la cuadrícula, filtra más, o agrega en su lugar: agrupa el archivo por mes, por cliente o por estado, y abre el resumen, que son unos cientos de filas en lugar de un millón. Un resumen suele ser el entregable real de todos modos, y es el archivo que tus colegas pueden abrir de verdad, algo que conviene recordar cuando envías resultados a otra persona.

import csv

kept = 0
with open('big.csv', newline='') as src, \
     open('filtered.csv', 'w', newline='') as dst:
    reader = csv.DictReader(src)
    writer = csv.DictWriter(dst, fieldnames=reader.fieldnames)
    writer.writeheader()
    for row in reader:
        if int(row['total']) > 90:
            writer.writerow(row)
            kept += 1
print(f'kept {kept} rows')

# Verified on the 1,200,000-row sample file:
# kept 74226 rows -> filtered.csv has 74,227 lines
# First kept row: 91,Customer 91,91
# The script reads one row at a time, so memory stays flat
# no matter how large the file is.

Fíjate en lo que el filtro prueba sobre el archivo en sí: nada en la receta depende de lo grande que sea el archivo, porque el script nunca guarda más de una fila en memoria. Esa es la diferencia entre una herramienta hecha para flujos y una herramienta hecha para cuadrículas. Una hoja de cálculo carga en memoria de una vez todo lo que muestra, y por eso tiene un límite. Un script de flujo procesa una fila, la escribe o la descarta, y pasa a la siguiente, y por eso no tiene límite práctico. Cuando el archivo es demasiado grande para la cuadrícula, recurre primero a la herramienta de flujo, y abre solo el resultado pequeño en la cuadrícula.

Solución 4: usa la herramienta adecuada para el trabajo

Si sigues chocando con el límite de la cuadrícula, la respuesta honesta puede ser que una hoja de cálculo es la herramienta equivocada para el conjunto de datos, y ninguna solución dentro de Excel cambiará eso. Un editor de texto es la herramienta adecuada para inspeccionar un archivo grande: abre todo el archivo como texto, te deja buscar un valor, y te muestra las primeras y las últimas filas, sin límite de filas salvo la memoria. Una base de datos es la herramienta adecuada para analizar un archivo grande: importa el CSV a SQLite, que es un solo archivo en tu equipo y no necesita servidor, y un millón de filas se convierte en una tabla pequeña que puedes consultar, filtrar y agregar con SQL, sin ninguna cuadrícula de por medio.

La elección entre esas herramientas depende de la pregunta. Si la pregunta es qué hay en el archivo, usa un editor de texto. Si la pregunta es qué filas cumplen una condición, usa un script de filtro. Si la pregunta es un total o una tabla dinámica sobre todo el archivo, usa el Data Model o una base de datos. Si la pregunta es echar un vistazo a unas pocas filas, usa head y tail en una terminal. Solo si la pregunta es editar fila a fila un subconjunto deberían estar los datos en una hoja de cálculo, y entonces solo el subconjunto, dividido o filtrado hasta que quepa. Forzar un conjunto de datos de un millón de filas dentro de una cuadrícula de un millón de filas es el desajuste, no el conjunto de datos.

También hay un punto de planificación, para quienes producen estos archivos. Si exportas un CSV cada semana y sigue creciendo más allá de un millón de filas, deja de exportar todo el historial cada vez y exporta solo las filas nuevas, o solo el resumen, o divide la exportación por mes en el origen. La exportación que cabe en una hoja de cálculo es la exportación que la gente puede usar de verdad, y una exportación que nadie puede abrir no es un entregable, por completa que sea. Di a los destinatarios el recuento de filas en el nombre del archivo o en una nota de una línea con el archivo, para que nadie descubra el límite perdiendo datos en un guardado recortado.

Cuatro soluciones que no funcionan

Antes de las soluciones que funcionan, conviene despejar las cuatro soluciones que no funcionan, porque cada una hace perder tiempo y una de ellas destruye datos. La primera es comprimir el archivo en un ZIP. La compresión reduce el archivo en disco, a veces mucho, porque el texto CSV se comprime bien, pero en el momento en que lo extraes o lo importas, los datos sin comprimir siguen teniendo el mismo número de filas, y Excel sigue deteniéndose en 1,048,576. La compresión cambia el almacenamiento, no el recuento de filas, y el límite de la cuadrícula cuenta filas, no megabytes.

La segunda es guardar el archivo como .xlsx, o pedirle a alguien que lo convierta por ti. El formato .xlsx tiene el mismo límite de 1,048,576 filas de cuadrícula que un CSV abierto en Excel, porque el límite pertenece a la hoja, no al formato de archivo, así que convertir el archivo no cambia nada sobre cuántas filas caben en una hoja. La tercera es abrir el archivo en Google Sheets y esperar que el límite de celdas te salve. Sheets puede tener más filas que Excel cuando el archivo es estrecho, porque cuenta 20 millones de celdas en lugar de filas, pero un archivo ancho alcanza el tope de celdas antes, también se aplica un tope de importación de 100 MB, y un archivo de 5 millones de filas supera también a Sheets, así que la solución solo funciona para archivos que superan el límite de Excel por poco, no para archivos realmente grandes.

La cuarta es dividir el archivo a mano dentro de Excel, copiando filas a hojas nuevas o a libros nuevos. Eso parte del libro recortado, donde las filas que pasan del límite ya faltan, así que la copia nunca puede incluirlas, y la copia manual es lenta, propensa a errores y limitada a las filas que Excel cargó en primer lugar. Divide desde el archivo original en disco con un script, antes de que Excel lo toque, como hace la receta de arriba. Y la solución que destruye datos de forma activa, en lugar de simplemente fallar, es guardar encima del original desde el libro recortado, lo que borra las filas no cargadas para siempre, como explica a fondo la guía complementaria sobre guardar.

Qué significa esto para los archivos de este convertidor

El convertidor de esta página produce exactamente el tipo de archivo del que trata esta guía, así que conviene exponer su comportamiento con claridad, verificado con el código real en lugar de suponerlo. El motor de conversión se ejecutó en este equipo con una muestra JSON de 10,000 filas y terminó en 28 milisegundos, produciendo 10,000 filas y 3 columnas, y con una muestra de 100,000 filas terminó en 218 milisegundos, produciendo un CSV de 2.35 MB. Una ejecución anterior de esta misma serie midió 100,000 filas en unos 0.4 segundos y 500,000 filas en unos 1.4 segundos de tiempo de motor, así que el convertidor en sí maneja archivos grandes con comodidad, y el cuello de botella es el programa que abre el resultado, no la conversión.

Esa distinción importa, porque decide dónde solucionar el problema. Si tu archivo convertido no se abre completo en Excel, la conversión no falló y el archivo no está dañado: el archivo tiene todas las filas, byte a byte, y Excel cargó solo las primeras 1,048,576. Comprueba el recuento de filas con la receta del principio de esta guía, y si el archivo supera el límite, divídelo con el script de arriba, o cárgalo a través de Power Query en el Data Model, o fíltralo hasta dejar las filas que necesitas. No conviertas otra vez esperando un resultado distinto, porque el convertidor producirá el mismo archivo completo, y Excel lo recortará de la misma forma.

Un detalle más del convertidor importa aquí. La descarga es UTF-8 plano, sin marca de orden de bytes, que es la forma más limpia para la mayoría de las herramientas, y el convertidor te deja elegir el delimitador antes de descargar. Ninguna de las dos elecciones afecta al límite de filas de ninguna forma: un archivo delimitado por punto y coma se recorta exactamente en la misma fila que uno delimitado por comas, y un archivo UTF-8 se recorta exactamente en la misma fila que uno con codificación antigua. Si tu archivo convertido también se abre en una columna, o muestra caracteres raros, esos son problemas distintos con soluciones distintas, cubiertos en las guías complementarias enlazadas abajo, y se pueden corregir en la misma importación que soluciona el tamaño. Corrige la apertura, divide el archivo si hace falta, y nunca guardes encima de la descarga desde Excel.

Engine check, run on this machine (2026-11-09):
10,000 rows -> 28 ms, 3 columns, 226,762 bytes
100,000 rows -> 218 ms, 3 columns, 2.35 MB

Sample output, first rows:
id,name,total
1,Customer 1,1
2,Customer 2,2

Earlier verified timings in this series:
100,000 rows / 10 MB JSON in about 0.4 s
500,000 rows / 25 MB JSON in about 1.4 s engine time

The converter finishes in milliseconds. The file it writes
is complete. Excel is the bottleneck, not the conversion.

Si el archivo que necesitas es la propia salida convertida, y es demasiado grande para Excel, el camino más limpio suele ser conservar el JSON y convertir de nuevo cada vez que necesites un CSV nuevo, en lugar de guardar un CSV gigante y dividirlo cada vez. El JSON es la fuente, el CSV es una instantánea, y regenerar desde la fuente siempre es más limpio que reparar un archivo que ya ha pasado por una hoja de cálculo. Es el mismo hábito de la copia maestra que recomienda la guía complementaria sobre guardar, aplicado a archivos grandes: conserva la fuente, exporta lo que necesitas, y divide o filtra la exportación, nunca la fuente.

Lista de prevención: produce archivos CSV que la gente pueda abrir de verdad

Los límites de filas son un desajuste entre quien escribe y quien lee, así que la prevención consiste en que quien escribe declare el tamaño, y en que quien lee compruebe antes de confiar. Repasa esta lista cuando produzcas o recibas un CSV, y la próxima persona que lo toque no necesitará esta guía. Primero, cuenta las filas antes de enviar un archivo, y pon el recuento en el nombre del archivo o en una nota de una línea con él, para que el destinatario sepa antes de abrirlo si el archivo cabe en una hoja de cálculo. Un archivo llamado customers-2026-11-09-1200000-rows.csv avisa a su lector; un archivo llamado customers.csv no avisa.

Segundo, divide en el origen cuando la exportación vaya a superar el límite. Si los datos vienen de una base de datos, exporta por mes o por región, para que cada archivo quepa en una cuadrícula por sí solo, en lugar de exportar todo el historial en un solo archivo que nadie puede abrir. Tercero, conserva los datos de origen, ya sean JSON, una base de datos o un libro, para que un archivo que se recorte o se guarde encima se pueda regenerar limpio en lugar de repararse. Cuarto, nunca guardes encima de un original desde un libro recortado, y revisa cada archivo que recibas en un editor de texto o con un recuento de filas antes de dejar que ninguna hoja de cálculo guarde encima de él.

Quinto, di a los destinatarios cómo abrir el archivo: una nota de una línea que diga que el archivo tiene 1,200,000 filas y que debe dividirse con el script de esta guía, o cargarse a través de Power Query en el Data Model, evita toda esta clase de problemas, y no cuesta nada incluirla con el archivo. La mayoría de las historias de terror con CSV terminan con alguien que descubre demasiado tarde que el archivo recortado era la única copia, o que un resumen se calculó a partir de un conjunto de datos parcial. Cuenta primero, divide o filtra antes de abrir, y mantén el original a salvo, y un CSV grande vuelve a ser un archivo normal.

Guías relacionadas

• El archivo CSV se abre en una sola columna en Excel: por qué pasa y cómo corregirlo (Guía 2026) →
• Por qué guardar tu CSV en Excel lo cambia y cómo mantener el original a salvo (Guía 2026) →
• Por qué Excel elimina los ceros a la izquierda de tus códigos CSV y cómo conservarlos (Guía 2026) →

Preguntas frecuentes