Validador de JSONL

Valida tus archivos JSONL (JSON Lines) al instante. Comprueba que cada línea tenga una sintaxis JSON correcta. La validación se ejecuta 100% en el cliente: tus datos nunca salen de tu navegador.

Comprobar según

JSONL de entrada

Suelta aquí un archivo .jsonl o haz clic para seleccionarlo

Admite archivos .jsonl, .ndjson, .json y .txt

Resultado de la validación

Pega contenido JSONL o suelta un archivo para validarlo

Guía de errores: qué falla y cómo corregirlo

Casi todos los archivos JSONL no válidos fallan por uno de estos seis motivos. Esta tabla relaciona el error que verás con su causa concreta a nivel de bytes y la forma más rápida de corregirlo. Según el RFC 8259, JSON es estricto en todos estos aspectos; JSONL añade además la regla de un registro por línea:

Ejemplo de línea con erroresProblemaSolución
{"a": 1,}Coma al final: se permite en JavaScript, pero no en JSONElimina la coma antes de } o ]
{'a': 1}Comillas simples: las cadenas JSON deben usar comillas doblesSustituye ' por " en las claves y en los valores de tipo cadena
{"note": "line oneUn salto de línea sin escapar dentro de una cadena divide el registro en varias líneasEscápalo como \n para mantener el registro en una sola línea
{"a": 1}Hay un BOM UTF-8 justo antes del primer registroGuarda el archivo sin BOM o elimina los tres primeros bytes
{"a": 1} {"b": 2}Hay dos registros en una misma línea: el parser detecta contenido sobrante al finalColoca cada registro en una línea independiente
(línea en blanco)En sentido estricto, no es un registro; algunos parsers dan error y otros la omitenElimina las líneas en blanco o configura las herramientas que leen el archivo para que las omitan

Cómo validar archivos JSONL

La validación de JSONL comprueba que cada línea de tu archivo contenga JSON válido. Cada línea debe contener un valor JSON completo que se pueda parsear, normalmente un objeto JSON.

Nuestro validador lee todo tu archivo JSONL en el navegador. No se envía ningún dato a ningún servidor. Solo tienes que pegar el texto JSONL o arrastrar y soltar un archivo para ver los resultados de la validación al instante.

Las líneas con errores aparecen resaltadas junto con su número de línea y el mensaje de error correspondiente. Puedes copiar el informe de validación para compartirlo con tu equipo o usarlo para corregir los problemas.

Validación de archivos de fine-tuning de OpenAI

La subida de un archivo de fine-tuning falla si alguna línea no cumple el formato de chat de OpenAI. Selecciona «Formato de fine-tuning de OpenAI» en el validador de arriba para localizar todas las líneas con errores antes de subir el archivo. En cada línea se comprueba:

  • que exista un array "messages" y que no esté vacío
  • que cada mensaje tenga un rol: system, user, assistant o tool
  • que el contenido sea una cadena o una lista de partes de contenido (puede omitirse en un mensaje de assistant que solo haga una llamada a una herramienta)
  • que haya al menos un mensaje de assistant, del que aprende el modelo
  • que "weight" tenga un valor de 0 o 1 y solo se use en mensajes de assistant
  • si hay líneas en el formato antiguo prompt/completion o en el formato de preferencias (DPO), que requieren una configuración diferente

También cuenta los ejemplos y los mensajes, avisa si el archivo tiene menos de los 10 ejemplos que exige OpenAI y ofrece una estimación aproximada de tokens para que puedas valorar el tamaño del entrenamiento. Para conocer el formato, consulta la guía del formato JSONL de OpenAI.

Errores comunes y soluciones

Comas al final de los objetos JSON

Una coma después del último par clave-valor de un objeto JSON (por ejemplo, {"name":"Alice",}) hace que el JSON no sea válido. Elimina la coma que sigue a la última propiedad de cada línea para corregir este error de sintaxis habitual.

Claves de propiedades sin comillas

En JSON, todas las claves de las propiedades deben ir entre comillas dobles. Las claves escritas como {name:"Alice"} no superarán la validación. Asegúrate de usar comillas dobles en todas las claves: {"name":"Alice"}.

Secuencias de escape no válidas en cadenas

JSON solo admite determinadas secuencias de escape (\n, \t, \", \\, etc.). Las secuencias no válidas como \x o \' provocan errores de parseo. Usa las secuencias de escape correctas de JSON o codifica los caracteres especiales como Unicode (\uXXXX).

Validación en CI y desde la línea de comandos

Usa estos comandos para comprobar que cada línea contiene exactamente un valor JSON antes de ejecutar un pipeline. Leen una línea cada vez, por lo que el uso de memoria depende del registro más grande, no del archivo completo. Las líneas vacías se rechazan; el salto de línea final es opcional.

# jq: parse each line and stop on the first error; empty needs no -e
jq -R 'try (
  if startswith("\uFEFF") then error("UTF-8 BOM is not allowed")
  else fromjson end | empty
) catch halt_error(1)' data.jsonl && echo OK


# Python: reject non-standard constants and report the first broken line
python3 - <<'PYTHON'
import json
import sys


def reject_constant(value):
    raise ValueError(f"Invalid JSON constant: {value}")


with open("data.jsonl", "r", encoding="utf-8") as source:
    for line_number, line in enumerate(source, 1):
        try:
            json.loads(line, parse_constant=reject_constant)
        except ValueError as error:
            sys.exit(f"Line {line_number}: {error}")
print("OK")
PYTHON

Estas comprobaciones no verifican los campos obligatorios, los tipos de los campos ni las reglas de los datos de entrenamiento de OpenAI; para ello, usa la validación de esquemas. jq acepta algunos literales numéricos no estándar, incluidos NaN e Infinity. Usa el ejemplo de Python cuando sea necesario rechazarlos.

¿Qué es la validación de JSONL?

Validar un archivo JSONL consiste en comprobar que cada línea contenga JSON con una sintaxis correcta. Es un paso fundamental antes de usar estos archivos para entrenar modelos de aprendizaje automático, realizar operaciones por lotes con APIs o procesar datos en pipelines.

La validación detecta problemas habituales como comas que faltan o sobran, claves sin comillas, comas al final, corchetes o llaves mal emparejados, secuencias de escape no válidas y problemas de codificación, como los caracteres BOM.

Casos de uso comunes

Control de calidad de los datos
Valida las exportaciones JSONL antes de importarlas en bases de datos o plataformas de análisis para evitar que los datos se corrompan.
Validación de datasets de ML
Comprueba que los datasets de fine-tuning de OpenAI y los datos de entrenamiento de Hugging Face tengan el formato correcto antes de subirlos.
Depuración de pipelines de datos
Localiza líneas con un formato incorrecto en archivos de logs JSONL y en la salida de datos en streaming.
Comprobación antes de subir archivos
Valida los archivos JSONL antes de subirlos a APIs que exigen un cumplimiento estricto del formato.
Validación en pipelines de CI/CD
Integra la validación de JSONL como un paso en tus pipelines de CI/CD para detectar archivos de datos con un formato incorrecto antes de que lleguen a producción.
Comprobación de la coherencia del esquema
Comprueba que todas las líneas de un archivo JSONL se puedan parsear correctamente y revisa visualmente si los registros siguen una estructura de esquema coherente.

Preguntas frecuentes

¿Qué comprueba la validación de JSONL?

La validación de JSONL comprueba que cada línea no vacía de tu archivo contenga JSON con una sintaxis válida. Revisa que los corchetes y las llaves estén bien emparejados, que las cadenas estén correctamente entrecomilladas, que las secuencias de escape sean válidas y que la estructura general del JSON sea correcta.

¿Están seguros mis datos durante la validación?

Sí. Toda la validación se realiza localmente en tu navegador. No se envía ningún dato a ningún servidor. Tu contenido JSONL nunca sale de tu dispositivo.

¿Puedo validar archivos JSONL grandes?

Sí. El validador puede procesar archivos grandes porque trata cada línea de forma independiente. Con archivos muy grandes (100MB+), la validación puede tardar unos segundos.

¿Qué debo hacer si falla la validación?

Revisa los detalles del error de cada línea no válida. Las correcciones más habituales son añadir las comillas que faltan, eliminar las comas al final y comprobar que los corchetes y las llaves estén bien emparejados. También puedes usar nuestro formateador de JSONL para identificar problemas de formato.

¿El validador comprueba que todas las líneas tengan un esquema coherente?

El validador solo comprueba la sintaxis del JSON, no la coherencia del esquema. Valida cada línea de forma independiente para asegurarse de que contenga JSON válido. Para validar el esquema, necesitas un validador de JSON Schema además de la comprobación de sintaxis.

¿Puedo validar archivos NDJSON o JSON Lines con distintas extensiones?

Sí. El validador admite archivos con las extensiones .jsonl, .ndjson, .json y .txt. El contenido se procesa de la misma forma, sea cual sea la extensión: cada línea no vacía se valida como JSON.

¿Cómo se tratan las líneas vacías y las que solo contienen espacios en blanco?

Las líneas vacías y las que solo contienen espacios en blanco se omiten automáticamente durante la validación. No se consideran errores ni aparecen en el informe de validación. Este comportamiento sigue la especificación de JSONL.

¿Puede esta herramienta corregir automáticamente un archivo JSONL no válido?

El validador detecta los errores y los muestra, pero no los corrige automáticamente. Una corrección automática podría alterar los datos que querías representar. Usa los detalles de cada error para corregirlo manualmente y vuelve a validar el archivo para confirmar que todas las líneas superen la validación.

Herramientas y guías relacionadas