JSONL vs Parquet: Eligiendo el formato de datos adecuado
Una comparacion completa de JSONL (JSON Lines) y Apache Parquet. Comprende las ventajas y desventajas en compresion, rendimiento de consultas, aplicacion de esquemas y soporte del ecosistema para elegir el formato correcto para tus cargas de trabajo de datos.
Ultima actualizacion: febrero 2026
¿Que es JSONL?
JSONL (JSON Lines) es un formato de datos basado en texto donde cada linea contiene un unico objeto JSON autocontenido separado por caracteres de nueva linea. Es una extension natural del ubicuo formato JSON, disenado especificamente para streaming y datos de estilo log. Debido a que cada linea es un documento JSON independiente, se pueden agregar datos a los archivos sin reescribir los existentes, y se pueden procesar linea por linea con una sobrecarga minima de memoria.
JSONL se ha convertido en el formato estandar de intercambio para datos de entrenamiento de aprendizaje automatico (fine-tuning de OpenAI, datasets de Hugging Face), logs de aplicaciones, flujos de eventos y cualquier escenario donde los datos llegan de forma incremental. Su naturaleza legible por humanos facilita la inspeccion con cualquier editor de texto o herramienta de linea de comandos como grep, head y jq.
{"id": 1, "name": "Alice", "role": "engineer", "salary": 95000}{"id": 2, "name": "Bob", "role": "designer", "salary": 88000}{"id": 3, "name": "Charlie", "role": "manager", "salary": 105000}
¿Que es Parquet?
Apache Parquet es un formato de almacenamiento binario columnar disenado para consultas analiticas eficientes sobre grandes conjuntos de datos. En lugar de almacenar datos fila por fila como JSONL, Parquet organiza los valores por columna, lo que significa que leer un solo campo a traves de millones de filas requiere escanear solo la columna relevante en lugar de cada registro completo. Este diseno columnar permite una compresion agresiva porque los valores dentro de una columna tienden a ser similares en tipo y distribucion.
Parquet fue creado dentro del ecosistema Apache Hadoop y ahora es el formato de almacenamiento de facto para data lakes construidos sobre AWS S3, Google Cloud Storage y Azure Blob Storage. Esta profundamente integrado con Apache Spark, Apache Hive, Presto, DuckDB, Snowflake, BigQuery y practicamente todos los motores de analitica modernos. Los archivos Parquet incorporan un esquema estricto en sus metadatos, por lo que los consumidores siempre conocen los tipos exactos y la estructura de los datos sin documentacion externa.
import pyarrow.parquet as pqimport pandas as pd# Write a DataFrame to Parquetdf = pd.DataFrame({'id': [1, 2, 3],'name': ['Alice', 'Bob', 'Charlie'],'role': ['engineer', 'designer', 'manager'],'salary': [95000, 88000, 105000]})df.to_parquet('employees.parquet')# Read specific columns (columnar advantage)df = pq.read_table('employees.parquet', columns=['name', 'salary']).to_pandas()
JSONL vs Parquet: Comparacion lado a lado
La siguiente tabla resume las diferencias clave entre JSONL y Parquet en las dimensiones que mas importan al elegir un formato de datos para tu proyecto.
| Caracteristica | JSONL | Parquet |
|---|---|---|
| Disposicion de datos | Orientado a filas, basado en texto. Cada linea es un objeto JSON completo. | Orientado a columnas, binario. Valores almacenados por columna con grupos de filas. |
| Codificacion | Texto plano UTF-8. Legible por humanos, editable en cualquier editor de texto. | Binario con codificaciones de diccionario, RLE y empaquetado de bits. No legible por humanos. |
| Compresion | Compresion externa opcional (gzip, zstd). Nombres de campos repetidos en cada fila. | Compresion columnar integrada (Snappy, Zstd, Gzip). Archivos 2-10x mas pequenos. |
| Rendimiento de consultas | Debe escanear el archivo completo para cualquier consulta. Sin poda de columnas ni pushdown de predicados. | La poda de columnas y el pushdown de predicados omiten datos irrelevantes. Ordenes de magnitud mas rapido para consultas analiticas. |
| Esquema | Sin esquema. Cada linea puede tener campos y tipos diferentes. Flexible pero propenso a errores. | Esquema tipado estricto incorporado en los metadatos del archivo. Aplicado en lectura y escritura. |
| Streaming / Adicion | Excelente. Agrega una nueva linea al final del archivo. Ideal para ingestion en tiempo real. | Deficiente. Requiere reescritura o creacion de nuevas particiones de archivo para agregar datos. |
| Legible por humanos | Si. Inspecciona con cat, head, grep, jq o cualquier editor de texto. | No. Requiere herramientas especializadas (parquet-tools, PyArrow, DuckDB) para inspeccionar. |
| Ecosistema | Universal. Soportado por todos los lenguajes de programacion con un analizador JSON. | Enfocado en analitica. Integracion profunda con Spark, Hive, Presto, DuckDB, Snowflake, BigQuery. |
Benchmarks de rendimiento
La brecha de rendimiento entre JSONL y Parquet se vuelve dramatica a escala. A continuacion se presentan benchmarks representativos para un conjunto de datos de 10 millones de filas con 20 columnas (una mezcla de cadenas, enteros, flotantes y marcas de tiempo).
Tamano de archivo (Compresion)
Escaneo completo de tabla
Velocidad de escritura
Consulta de una sola columna
Benchmarks medidos con Python (pandas + PyArrow) en un MacBook Pro M2 con 16 GB de RAM. Los resultados reales varian segun el hardware, la distribucion de datos y el codec de compresion.
Cuando usar JSONL vs Parquet
- Ingestion de logs en tiempo real y streaming de eventos
- Datos de entrenamiento ML para OpenAI, Anthropic y Hugging Face
- Intercambio de datos entre microservicios y APIs
- Datos semiestructurados con esquemas variables por registro
- Prototipado rapido y depuracion donde la legibilidad humana importa
- Datos de solo adicion donde los registros llegan continuamente
- Conjuntos de datos pequenos a medianos (menos de 1 GB) que no necesitan consultas analiticas
- Almacenamiento en data lake en S3, GCS o Azure Blob
- Consultas analiticas con Spark, Presto, DuckDB o Snowflake
- Agregaciones columnares (SUM, AVG, COUNT) sobre miles de millones de filas
- Aplicacion estricta de esquemas y requisitos de gobernanza de datos
- Archivado a largo plazo donde el costo de almacenamiento importa (archivos 2-10x mas pequenos)
- Feature stores y pipelines de caracteristicas ML que leen columnas especificas
- Conjuntos de datos mayores de 1 GB donde el rendimiento de consultas es critico
Arquitectura hibrida: ingestion JSONL, almacenamiento Parquet
En plataformas de datos en produccion, JSONL y Parquet no son mutuamente excluyentes. Un patron comun y efectivo es usar JSONL para la ingestion de datos y Parquet para almacenamiento a largo plazo y analitica. Este enfoque hibrido combina las fortalezas de ambos formatos: la simplicidad de JSONL para captura de datos en tiempo real y la eficiencia de Parquet para consultas posteriores.
El pipeline funciona en tres etapas. Primero, los eventos o registros sin procesar se agregan a archivos JSONL a medida que llegan, porque JSONL soporta adiciones rapidas y sin bloqueo. Segundo, un trabajo por lotes periodico (cada hora, diariamente, o activado por tamano de archivo) lee los archivos JSONL acumulados, valida y transforma los datos, y los convierte a formato Parquet. Tercero, los archivos Parquet resultantes se almacenan en un data lake particionado por fecha, region u otras dimensiones para consultas eficientes.
1. Ingestar como JSONL
Recopila eventos sin procesar, logs y respuestas de API como archivos JSONL. Adiciones rapidas, sin esquema requerido y facil de depurar en tiempo real.
2. Transformar y validar
Lee periodicamente lotes de JSONL, aplica validacion de esquema, limpia y normaliza datos, y maneja registros malformados.
3. Almacenar como Parquet
Escribe datos validados como archivos Parquet particionados en tu data lake. Consulta con Spark, DuckDB o cualquier motor de analitica.
import jsonimport pandas as pdimport pyarrow as paimport pyarrow.parquet as pqfrom pathlib import Pathfrom datetime import datetimedef jsonl_to_parquet(jsonl_dir: str, parquet_dir: str):"""Convert accumulated JSONL files to partitioned Parquet."""records = []for jsonl_file in Path(jsonl_dir).glob('*.jsonl'):with open(jsonl_file, 'r') as f:for line in f:line = line.strip()if line:records.append(json.loads(line))if not records:returndf = pd.DataFrame(records)# Add partition columndf['date'] = datetime.now().strftime('%Y-%m-%d')table = pa.Table.from_pandas(df)pq.write_to_dataset(table,root_path=parquet_dir,partition_cols=['date'],compression='zstd')print(f'Converted {len(records)} records to Parquet')jsonl_to_parquet('raw_events/', 'data_lake/')
Prueba nuestras herramientas JSONL gratuitas
¿Trabajas con archivos JSONL? Usa nuestras herramientas gratuitas basadas en navegador para ver, validar y convertir datos JSONL al instante. Sin instalacion ni subidas necesarias.