Convert Large JSON to CSV Online Free: ¿qué tan grande es demasiado grande? (Guía 2026)

La respuesta corta

Sí. Sube el archivo al conversor de esta página y descarga el CSV: sin registrarte, sin límite de tamaño de archivo por nuestra parte, y tus datos nunca salen de tu máquina porque la conversión se ejecuta por completo en tu navegador. Medido en la máquina de compilación con el mismo motor de conversión que usa esta página, 100 000 filas (unos 10 MB de JSON) se convierten en menos de medio segundo, y 500 000 filas (unos 25 MB) en aproximadamente dos segundos. La conversión misma casi nunca es el cuello de botella. Lo que limita una pestaña del navegador es la memoria: analizar el JSON en objetos y renderizar la tabla de vista previa. La regla práctica: hasta unas 100 000 filas, conviértelo aquí directamente. Más allá de eso, divide el archivo en fragmentos, convierte cada fragmento en la pestaña y vuelve a unir los CSV, una receta que esta guía verifica byte por byte. Y si el archivo es tan grande que la pestaña muere antes de convertir nada, el trabajo le corresponde a un script, no a un navegador, y esta guía también muestra ese script.

Qué significa realmente «grande» para un conversor de navegador

Cuando alguien dice que un archivo JSON es grande, puede significar desde cinco mil filas hasta cinco gigabytes, y esos son problemas completamente distintos. Un conversor de navegador no tiene un solo límite. Tiene tres, y saber cuál estás a punto de alcanzar te dice si debes convertir directamente, fragmentar o salir del navegador por completo.

El primer límite es el análisis. Antes de que ocurra cualquier conversión, el navegador convierte tu texto JSON en objetos en memoria con JSON.parse, y los objetos analizados ocupan aproximadamente dos o tres veces la memoria del texto del que provienen. Un archivo de 25 MB se convierte en 50 a 75 MB de objetos activos antes de que exista una sola celda CSV. El segundo límite es la entrada. Pegar cincuenta megabytes de texto en un área de texto es lento y desagradable en cualquier máquina, por eso existe el botón de subir: entrega el archivo al conversor sin pasarlo por tu portapapeles. El tercer límite es la vista previa. Después de convertir, la página renderiza una tabla para que puedas revisar el resultado a simple vista, y renderizar medio millón de filas del DOM es lo que realmente congela las pestañas. Nota lo que falta en esta lista: la velocidad de conversión. Como muestran las mediciones de abajo, convertir los objetos en texto CSV es el paso más barato de todo el proceso.

Entonces «¿puedo convertir un archivo JSON grande en línea gratis?» en realidad plantea tres preguntas más pequeñas. ¿Podrá el navegador analizarlo sin quedarse sin memoria? ¿Manejará la ruta de entrada con elegancia? ¿Sobrevivirá la vista previa? Para la mayoría de los archivos que la gente llama grandes, la respuesta a las tres es sí, y el resto de esta guía trata de encontrar el límite con honestidad en lugar de adivinar.

Medido: qué tan rápido convierte archivos grandes esta página

Cada número de esta sección se midió en la máquina de compilación con el mismo motor de conversión que esta página ejecuta en tu navegador, la misma función jsonToCsv con el aplanado activado, contra datos de pedidos generados con objetos de cliente anidados. La máquina es un servidor común, no un equipo de referencia ajustado, así que trata estos números como el orden de magnitud correcto para una laptop decente.

Mil filas, 0,10 MB de JSON: 20 milisegundos. Diez mil filas, 1,01 MB: 57 milisegundos. Cincuenta mil filas, 5,10 MB: 221 milisegundos. Cien mil filas, 10,21 MB: 403 milisegundos. Doscientas cincuenta mil filas, 12,5 MB: 636 milisegundos. Quinientas mil filas, 25,0 MB: aproximadamente 1,4 segundos de tiempo de motor, 2,3 segundos de reloj. El CSV de salida del archivo de medio millón de filas fue de 11,7 MB, y la fila de encabezado salió exactamente como se esperaba: id, item, qty, price, customer.name, customer.city.

Dos advertencias honestas. Primera, estos tiempos son solo de la conversión. Tu navegador también analiza el JSON primero y renderiza la tabla de vista previa después, y la vista previa es la parte costosa en el extremo superior. Un archivo que se convierte en dos segundos puede hacer que la pestaña se sienta pesada mientras medio millón de filas de tabla se pintan. Segunda, los datos de prueba generados son uniformes. Las exportaciones reales con claves irregulares, anidado profundo o bloques de texto gigantes se convierten un poco más lento, porque el motor recorre cada valor. Aun así, la forma del resultado se mantiene: el paso de conversión se queda por debajo de un segundo mucho más allá de las cien mil filas, y se mantiene en pocos segundos a medio millón. Si tu archivo se convierte lento en otro sitio, el conversor está haciendo algo derrochador, porque el trabajo en sí es barato.

Tiempos de conversión medidos (motor de la página, máquina de compilación)

rows        JSON size    convert time
1,000       0.10 MB      20 ms
10,000      1.01 MB      57 ms
50,000      5.10 MB      221 ms
100,000     10.21 MB     403 ms
250,000     12.5 MB      636 ms
500,000     25.0 MB      ~1.4 s engine / 2.3 s wall

# header produced for every file:
# id,item,qty,price,customer.name,customer.city

La prueba de 60 segundos: pruébalo antes de diseñar una solución

La mayoría de la ansiedad por archivos grandes se resuelve simplemente probando. Usa el botón de subir en lugar de pegar para cualquier cosa mayor de unos pocos megabytes, y observa la insignia de estado sobre el conversor. Pasa de Listo a Válido con un conteo de filas cuando el JSON se analiza sin errores. Si la pestaña se mantiene receptiva y el botón de descarga te entrega un CSV, ya terminaste, y ninguna estrategia de fragmentación fue necesaria.

Dos detalles hacen honesta la prueba. Primero, mantén la Conversión automática activada, que es el valor predeterminado: el CSV aparece tan pronto como el archivo carga, así ves el resultado sin un clic adicional. Segundo, confía en el conteo de filas. Si la insignia dice Válido con 480 000 filas y esperabas más o menos esa cantidad, el análisis entendió tu archivo. Si el conteo está muy desviado, normalmente 1, tu JSON probablemente es un objeto gigante que envuelve al array, y el conversor extrajo lo que pudo. Eso es un problema de forma del archivo, no de tamaño, y nuestra guía de aplanado explica el patrón de envoltorio.

Si la pestaña se congela, tartamudea durante mucho tiempo o el navegador ofrece cerrar la página, detente y fragmenta. No recargues y pegues el mismo archivo esperando un resultado distinto. El límite de memoria no negocia, y la siguiente sección es el camino para superarlo.

Fragmentar en el navegador: la receta que nunca pierde una fila

Fragmentar suena como un compromiso, pero es exacto. Divide el array JSON en piezas, convierte cada pieza en la pestaña, descarga un CSV por pieza y vuelve a unirlos conservando una sola fila de encabezado. En la máquina de compilación esto se verificó directamente: un archivo de 20 000 filas dividido en dos mitades, cada mitad convertida por separado, el encabezado del segundo CSV eliminado, los dos cuerpos concatenados. El resultado unido fue idéntico byte por byte a convertir el archivo completo de una sola vez.

Vale la pena explicar por qué funciona en una frase. Cuando cada fragmento tiene la misma forma, el conversor deriva la misma lista de columnas en el mismo orden para cada fragmento, así los cuerpos se alinean perfectamente y lo único que hay que gestionar es el encabezado. Conserva el encabezado del primer CSV, elimina la línea de encabezado de cada CSV posterior y concatena. El único caso que necesita cuidado es el de datos irregulares, donde distintas filas llevan distintas claves: si el fragmento uno nunca vio una columna «notes» que el fragmento dos sí tiene, las columnas no se alinearán. Para archivos irregulares, usa la ruta del script en la sección posterior, que calcula primero la lista completa de columnas.

¿Cuántos fragmentos? Apunta a piezas que tu pestaña convierta con comodidad, lo que según las mediciones de arriba son unas 50 000 a 100 000 filas cada una. Un archivo de 400 000 filas se convierte en cuatro a ocho fragmentos, cada uno convirtiéndose en menos de medio segundo. Todo el trabajo, incluidos tus clics, toma unos minutos, y cada fila sobrevive.

Dividir el archivo sin romper el JSON

El error que hay que evitar es dividir el archivo como texto. Cortar un archivo de 25 MB por la mitad en un editor de texto casi siempre lo rompe: un corchete dejado abierto, una cadena cortada a mitad de comilla, una coma huérfana en el límite. Divídelo como datos, con una herramienta que entienda JSON, para que cada pieza siga siendo JSON válido por sí misma.

El divisor confiable más corto es unas pocas líneas de Python. Carga el archivo una vez, rebana la lista y vuelca cada rebanada a su propio archivo. Verificado en la máquina de compilación contra un archivo de 30 000 filas: tres piezas de 10 000 filas, y reensamblar las piezas reprodujo el archivo original exactamente. Si prefieres quedarte en la terminal, jq rebana arrays con la misma idea: jq '.[0:50000]' big.json > part1.json toma los primeros cincuenta mil elementos, y jq '.[50000:100000]' toma los siguientes cincuenta mil. Esa es la sintaxis de rebanado estándar de jq, documentada en el manual de jq.

Nombra las piezas en orden, part1, part2, part3, y conviértelas en orden. Los CSV salen en el mismo orden, y el paso de unión es solo concatenar con la regla de encabezado de la sección anterior.

Dividir un array JSON en piezas válidas (verificado)

import json

rows = json.load(open('big.json'))
chunk = 50000
for i in range(0, len(rows), chunk):
    part = rows[i:i+chunk]
    json.dump(part, open('part%d.json' % (i // chunk + 1), 'w'))
    print('part%d.json:' % (i // chunk + 1), len(part), 'rows')

# terminal alternative (standard jq slice syntax):
# jq '.[0:50000]' big.json > part1.json
# jq '.[50000:100000]' big.json > part2.json

Cuando el archivo es demasiado grande para cualquier pestaña del navegador

Hay un límite honesto, y vale la pena nombrarlo con claridad. Si el navegador no puede analizar el archivo en memoria en absoluto, ningún conversor en línea puede ayudar, porque todos analizan primero. Los síntomas son inconfundibles: la pestaña ofrece cerrar la página durante la carga, el navegador informa un error de falta de memoria o el archivo nunca termina de subir. En ese punto el archivo ha superado a la pestaña, y el trabajo le corresponde a un script que se ejecuta en tu máquina, que puede procesar los datos sin tenerlos todos como objetos a la vez.

¿Dónde está ese límite en la práctica? Depende de la RAM de tu máquina y de qué tan anidados estén los datos, pero los archivos de cientos de megabytes de texto JSON son donde las pestañas empiezan a morir en laptops comunes. Un archivo de 25 MB se convirtió aquí en unos dos segundos con margen de sobra; un archivo de 250 MB es otro animal, aproximadamente diez veces la presión de memoria, y un archivo de 1 GB es firmemente territorio de script. Si no estás seguro de qué lado de la línea estás, la prueba de 60 segundos de la sección anterior lo responde de forma empírica: una pestaña muerta es el archivo diciéndote que necesita un script.

Una nota honesta más. Algunos sitios anuncian «tamaño de archivo ilimitado» para la conversión en línea. Lo que suelen querer decir es que sus servidores aceptan la subida, lo que solo mueve el límite de tu navegador a su cola, y entrega tus datos a un tercero en el proceso. Para archivos lo bastante grandes como para importar, ese intercambio rara vez vale la pena.

La ruta del script: Python por fragmentos que sobrevive a datos irregulares

Cuando el navegador queda fuera, este es el script. Lee todo el archivo una vez, aplana cada fragmento con pandas y escribe un CSV por fragmento, y maneja el caso de datos irregulares que la receta del navegador no puede: filas con distintas claves. El truco es calcular primero la lista completa de columnas a partir de todos los datos, y luego forzar cada fragmento a esas columnas antes de escribir. Verificado en la máquina de compilación contra un archivo de 30 000 filas donde algunas filas llevaban un campo notes y otras un campo flag: tres CSV de fragmentos unidos en una salida idéntica byte por byte a convertir el archivo de una sola vez, en 0,4 segundos.

El patrón escala más allá de lo que el navegador jamás podría. Como cada fragmento se convierte y se escribe antes de que el siguiente cargue, el pico de memoria se mantiene proporcional al tamaño del fragmento, no al tamaño del archivo. Sube el tamaño del fragmento para ganar velocidad en una máquina grande, bájalo si la memoria está ajustada. Y el mismo truco de unión de columnas te protege siempre que las exportaciones cambien de forma a mitad de camino, cosa que a las exportaciones reales les encanta hacer.

Queda una decisión de criterio: un CSV por fragmento frente a un único archivo unido. El script de abajo escribe un archivo por fragmento, lo que mantiene cada pieza utilizable por separado. Si quieres un solo archivo, concaténalos con la misma regla de encabezado que la receta del navegador: conserva el encabezado del primer archivo, elimina el resto.

Conversión por fragmentos segura para datos irregulares (verificado, pandas)

import json, pandas as pd

rows = json.load(open('big.json'))
cols = list(pd.json_normalize(rows).columns)  # union of all keys

chunk = 50000
for i in range(0, len(rows), chunk):
    part = pd.json_normalize(rows[i:i+chunk]).reindex(columns=cols)
    part.to_csv('out_part%d.csv' % (i // chunk + 1), index=False)

# merge the parts into one CSV (keep one header):
# head -n 1 out_part1.csv > merged.csv
# tail -n +2 -q out_part*.csv >> merged.csv

Archivos grandes y privacidad: por qué el lado del cliente importa más a escala

Los archivos grandes suelen ser archivos sensibles. Una exportación de 500 000 filas rara vez es un conjunto de datos de juguete; son clientes, pedidos, registros o historiales de pacientes. Justo entonces es cuando la arquitectura del conversor más importa, y es la ventaja silenciosa de hacer esto en una pestaña del navegador en lugar de en el servidor de alguien.

El conversor de esta página se ejecuta por completo en tu navegador después de que la página carga. Eso se verificó contra el propio código fuente de la página para nuestra guía de descarga: el motor de conversión se importa como código local del lado del cliente, y la única solicitud de red en todo el conversor es el botón opcional de obtener desde URL, que solo se ejecuta cuando haces clic en él y solo obtiene la dirección que escribes. Tus datos pegados o subidos nunca se envían a ningún sitio, lo que significa que ningún tercero ve el archivo, ninguna cola de subida en la que esperar y ninguna política de retención que leer.

Por eso la receta de fragmentación de arriba también es segura para datos privados. Cada fragmento se convierte en tu máquina, y las piezas nunca la abandonan. Si tu archivo es lo bastante grande como para necesitar la ruta del script, se mantiene la misma propiedad: el script de Python se ejecuta localmente, y nada en él toca la red.

Qué no hacer con un archivo grande

Cuatro errores aparecen constantemente. Primero, pegar decenas de megabytes en el cuadro de entrada en lugar de usar el botón de subir. La ruta de subida existe precisamente para esto, y pegar es la forma más lenta de meter un archivo grande en cualquier página. Segundo, minificar el JSON con la esperanza de que se reduzca lo suficiente como para importar. La minificación ahorra quizá un diez por ciento en exportaciones típicas, lo que convierte un archivo que es demasiado grande en un archivo que sigue siendo demasiado grande. Tercero, abrir un CSV de 500 000 filas en una hoja de cálculo para «revisarlo». Las hojas de cálculo tienen un tope de alrededor de un millón de filas y renderizan lento mucho antes de eso; revisa el conteo de filas y verifica por muestras el inicio y el final del archivo. Cuarto, convertir la misma exportación gigante a mano cada semana. Si el archivo llega con un horario, el script de Python de la sección anterior es una configuración única que supera a cincuenta conversiones manuales.

Y algo por lo que no hay que preocuparse: el aplanado. Los datos anidados no cambian de forma significativa las cuentas del tamaño. El interruptor de aplanado convierte los objetos anidados en columnas con notación de puntos, cosa que el motor hace en la misma pasada que todo lo demás, y las mediciones de arriba se tomaron todas con el aplanado activado.

Guías relacionadas

Preguntas frecuentes

¿Existe una herramienta gratuita en línea para convertir archivos JSON grandes a CSV?

Sí, el conversor de esta página es gratis, sin registro y sin límite de tamaño de archivo por nuestra parte. Sube el archivo, observa la insignia de estado confirmar el conteo de filas y descarga el CSV. Tus datos nunca salen de tu máquina porque la conversión se ejecuta por completo en tu navegador. Para archivos de más de unos cientos de miles de filas, divide primero el archivo en fragmentos con la receta de esta guía.

¿Cuál es el tamaño máximo de archivo JSON que puedo convertir en línea?

No hay un límite estricto en esta página; el límite práctico es la memoria de tu pestaña del navegador. Medido con el propio motor de la página, 25 MB / 500 000 filas se convierten en unos dos segundos, con margen de sobra. Más allá, la memoria de la pestaña para el análisis y la tabla de vista previa se convierte en el límite, no la conversión. Si la pestaña se congela o muere, fragmenta el archivo o cambia a la ruta del script de esta guía.

¿Cómo divido un archivo JSON grande en archivos más pequeños?

Divídelo como datos, no como texto, para que cada pieza siga siendo JSON válido. En Python: carga el archivo con json.load, rebana la lista en piezas y vuelca cada pieza con json.dump. En la terminal: jq '.[0:50000]' big.json > part1.json toma los primeros cincuenta mil elementos. Nunca cortes el archivo en un editor de texto, porque rompe corchetes y comillas en el límite.

¿La fragmentación cambia mi salida CSV?

No, siempre que cada fragmento tenga la misma forma. Verificado en la máquina de compilación: un archivo dividido por la mitad, convertido en dos piezas y reunido conservando un encabezado produjo una salida idéntica byte por byte a convertir el archivo completo de una vez. La excepción son los datos irregulares donde las filas llevan distintas claves; para eso, usa el script de esta guía, que calcula la lista completa de columnas antes de escribir cualquier fragmento.

¿Es seguro convertir en línea un archivo JSON grande con datos sensibles?

En esta página, sí. La conversión se ejecuta por completo en tu navegador: el motor es código local del lado del cliente y tu archivo nunca se sube a ningún servidor. La única solicitud de red en el conversor es el botón opcional de obtener desde URL. Eso hace que la ruta del navegador, y la receta de fragmentación, sean seguras para exportaciones privadas que no le entregarías a un servicio de terceros.

¿Por qué se congela mi navegador al convertir un archivo JSON grande?

Normalmente por la tabla de vista previa, no por la conversión. Renderizar cientos de miles de filas de tabla es mucho más costoso que producir el texto CSV. Pegar un archivo enorme en el cuadro de entrada en lugar de subirlo lo empeora. Sube el archivo, y si la pestaña sigue teniendo dificultades, convierte por fragmentos: cada pieza se mantiene lo bastante pequeña para que la vista previa se renderice al instante.

¿Puedo convertir un archivo JSON de 1 GB a CSV en un navegador?

Honestamente, no. Un archivo de ese tamaño supera lo que una pestaña del navegador puede analizar en memoria, y ningún conversor en línea cambia eso. Usa un script en tu máquina: Python con json_normalize por fragmentos como se muestra en esta guía, o una herramienta de transmisión para datos JSON-lines. Si el archivo es un array gigante, considera convertirlo primero a JSON-lines, un objeto por línea, que se transmite con limpieza.

Pruébalo ahora con tu archivo grande

Pega un trozo de tu JSON grande y mira cómo el conversor lo maneja en milisegundos. Gratis, sin registro, todo se ejecuta en tu navegador.

Abrir el conversor de JSON a CSV

Todas las guías