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.

employees.jsonl
{"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.

Lectura y escritura de Parquet con Python
import pyarrow.parquet as pq
import pandas as pd
# Write a DataFrame to Parquet
df = 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.

CaracteristicaJSONLParquet
Disposicion de datosOrientado a filas, basado en texto. Cada linea es un objeto JSON completo.Orientado a columnas, binario. Valores almacenados por columna con grupos de filas.
CodificacionTexto 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.
CompresionCompresion externa opcional (gzip, zstd). Nombres de campos repetidos en cada fila.Compresion columnar integrada (Snappy, Zstd, Gzip). Archivos 2-10x mas pequenos.
Rendimiento de consultasDebe 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.
EsquemaSin 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 / AdicionExcelente. 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 humanosSi. Inspecciona con cat, head, grep, jq o cualquier editor de texto.No. Requiere herramientas especializadas (parquet-tools, PyArrow, DuckDB) para inspeccionar.
EcosistemaUniversal. 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)

JSONL~4.2 GB sin comprimir, ~1.1 GB con gzip
Parquet~0.5 GB con Snappy, ~0.4 GB con Zstd

Escaneo completo de tabla

JSONL~45 segundos (analizar cada linea JSON)
Parquet~8 segundos (decodificacion binaria, lecturas vectorizadas)

Velocidad de escritura

JSONL~30 segundos (serializar + escribir texto)
Parquet~22 segundos (codificar + comprimir columnas)

Consulta de una sola columna

JSONL~45 segundos (debe leer el archivo completo)
Parquet~1.5 segundos (lee solo la columna objetivo)

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

JSONLMejor para JSONL
  • 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
ParquetMejor para Parquet
  • 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.

Pipeline de JSONL a Parquet
import json
import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq
from pathlib import Path
from datetime import datetime
def 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:
return
df = pd.DataFrame(records)
# Add partition column
df['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.

Trabaja con archivos JSONL online

Visualiza, valida y convierte archivos JSONL de hasta 1 GB directamente en tu navegador. Sin subidas necesarias, 100% privado.

Preguntas frecuentes

JSONL vs Parquet — Velocidad, almacenamiento y cuándo usa...