Convertidor de CSV a JSON

¿Qué es JSON y por qué convertir desde CSV?

// Input CSV (comma + LF, header on, infer types on)
id,name,active,score
1,Alice,true,98.5
2,Bob,false,87
3,Carol,true,

// Output JSON
[
  { "id": 1, "name": "Alice", "active": true, "score": 98.5 },
  { "id": 2, "name": "Bob", "active": false, "score": 87 },
  { "id": 3, "name": "Carol", "active": true, "score": null }
]

// Same input with Header off (no first-row keys)
1,Alice,true,98.5
2,Bob,false,87

// Becomes
[
  { "col1": 1, "col2": "Alice", "col3": true, "col4": 98.5 },
  { "col1": 2, "col2": "Bob", "col3": false, "col4": 87 }
]

Características principales

Ejemplos

id,name,email,role
1,Alice,alice@example.com,admin
2,Bob,bob@example.com,editor
3,Carol,carol@example.com,viewer
4,Dan,dan@example.com,viewer

ts	event	user	duration
2026-05-09T10:00:00Z	signup	alice	142
2026-05-09T10:01:00Z	login	alice	87
2026-05-09T10:02:00Z	checkout	alice	312
2026-05-09T10:03:00Z	logout	alice	44

id;name;price
1;Alice;1234,56
2;Bob;9876,54
3;Carol;42,00

name,role,note
"Smith, Jr.",admin,"He said ""hi"""
"Doe, Jane",editor,"Two
lines"

id,event,user
9007199254740993,signup,alice
9007199254740994,login,bob
9007199254740995,checkout,carol

1,Alice,admin
2,Bob,editor
3,Carol,viewer
4,Dan,viewer

Cómo usar

1. 1

   Pega tu CSV

   Introduce o pega tu CSV en el campo de entrada de arriba. La herramienta acepta datos delimitados por coma, punto y coma, tabulación y pipe. También puedes hacer clic en 'Cargar ejemplo' para probar una muestra como una exportación de hoja de cálculo, un log TSV o un CSV Excel-EU con punto y coma.

2. 2

   Elige el delimitador (o Tab)

   Haz clic en `,` (predeterminado), `;` (punto y coma Excel-EU), `\t` (TSV) o `|` (Pipe) para cambiar el delimitador con un solo clic. Abre el panel de Opciones para un control fino: Cabecera activada/desactivada e Inferir tipos activado/desactivado. Cabecera desactivada autonombra las columnas col1, col2, col3.

3. 3

   Copia o Descarga el JSON

   Haz clic en Copiar para llevar el JSON al portapapeles, o en Descargar para guardarlo como archivo .json listo para tu código, API o pipeline. Para ida y vuelta, haz clic en Invertir dirección para convertir JSON de vuelta a CSV en el mismo lugar.

Errores comunes de conversión

name,role
Smith, Jr.,admin
// Parser reads 3 columns: "Smith", " Jr.", "admin"

name,role
"Smith, Jr.",admin
// Parser reads 2 columns: "Smith, Jr.", "admin"

// Wrong delimiter (default comma) on Excel-EU file
id;name;price
1;Alice;1234,56
// Each row becomes one column: { col1: "1;Alice;1234,56" }

// Correct: pick `;` Delimiter chip
id;name;price
1;Alice;1234,56
// Output: { id: 1, name: "Alice", price: "1234,56" }

// Without big-int detection
{"id": 9007199254740993}
// JavaScript reads as 9007199254740992 (precision lost)

// With Infer types on, big integers stay as strings
{"id": "9007199254740993"}
// Use BigInt(value) in code to preserve precision

id, name, email
1, Alice, alice@example.com
// Output keys: "id", " name", " email" (with leading spaces)

id,name,email
1,Alice,alice@example.com
// Output keys: "id", "name", "email" (clean)

name,role,note
Alice,admin
Bob,editor,first day
// Row 1 is short by one cell

// Output (note empty/null cell in row 1)
[
  { "name": "Alice", "role": "admin", "note": null },
  { "name": "Bob", "role": "editor", "note": "first day" }
]

// Expecting a Date object in the output
ts,event
2026-05-09T10:00:00Z,signup
// Output ts is the string "2026-05-09T10:00:00Z", NOT a Date

// Correct: parse at the point of use in your code
const rows = JSON.parse(output);
const when = new Date(rows[0].ts);
// when is now a Date object

Casos de uso comunes

Exportación de Hoja de Cálculo a Importación de API

Pega un CSV exportado de Excel, Google Sheets o Numbers y obtén un array JSON de objetos listo para POST a una API REST, mutación GraphQL o endpoint de importación masiva. El caso de uso más común — los analistas producen datos de hoja de cálculo, los ingenieros necesitan JSON tipado para alimentar el backend.

Exportación de Excel a Tooling

Convierte exportaciones CSV de Excel (incluyendo archivos delimitados por punto y coma Excel-EU con el chip `;`) en JSON para procesar con tooling de JavaScript, scripts jq o cualquier sistema que lea JSON. El parser gestiona el stripping de BOM y los finales de línea CRLF correctamente para que las exportaciones de Excel no se rompan en la primera fila.

Log TSV a Analítica

Los logs separados por tabulaciones de exportaciones BigQuery, descargas Snowflake, pipelines Vector o herramientas Unix (cut, awk) suelen llegar como .tsv. Selecciona el chip de Delimitador Tab y obtén un array JSON tipado listo para análisis ad hoc, ingesta en dashboard o transformación en etapa de pipeline.

Volcado CSV de Base de Datos a ETL

Convierte la salida de PostgreSQL COPY TO CSV, MySQL SELECT INTO OUTFILE o cualquier volcado CSV de base de datos en JSON para cargar en un almacén NoSQL, alimentar un pipeline ETL de JavaScript o enviar a BigQuery como JSON delimitado por líneas. La detección de enteros grandes preserva los IDs numéricos que exceden el rango seguro de JavaScript.

Consumo de Resultados de Tests CSV de Postman/Newman

Las ejecuciones de tests de Postman exportan informes CSV de pass/fail por solicitud. Convierte a JSON para consumo programático — alimenta un dashboard de estado, pipeline de alertas o agregador de resultados de tests. Las filas con forma mixta (los tests fallidos tienen una columna error extra) se gestionan con rellenos vacíos/null.

CSV Pequeño a Configuración JSON Rápida

¿Tienes un CSV pequeño de constantes — códigos de moneda, nombres de país, SKUs de producto — y necesitas un array JSON para un archivo de configuración o una constante de JavaScript? Pega, copia, pega. Con Inferir tipos activado, los números y booleanos se tipan correctamente; con Cabecera activada, obtienes un array de objetos con campos nombrados listos para soltar en un archivo .json.

Detalles técnicos

Internals del Parser de Máquina de Estados RFC 4180

El parser es una implementación adecuada de máquina de estados finita siguiendo RFC 4180. Los estados incluyen UnquotedField, QuotedField, AfterQuote, RowEnd y EndOfInput. El parser gestiona correctamente campos entrecomillados que contienen el delimitador, CR/LF incrustados dentro de campos entrecomillados, comillas dobles escapadas (duplicadas, como "") y saltos de línea finales. Esto produce una salida que hace ida y vuelta sin pérdidas a través del módulo csv de Python, PostgreSQL COPY, AWS S3 SELECT y cualquier parser conforme. La máquina de estados es consciente del delimitador, así que cambiar de `,` a `;` o `\t` no cambia la semántica de entrecomillado — solo el separador de campo.

Algoritmo de Inferencia de Tipos

Con Inferir tipos activado, cada celda pasa por un pipeline de detección ordenado. Primero, una celda vacía se convierte en JSON null. Segundo, las cadenas literales true y false se convierten en booleanos JSON. Tercero, las cadenas con cero a la izquierda (^0[0-9]+$) se mantienen como cadenas para preservar la semántica de identificador — convertir a números eliminaría silenciosamente los ceros a la izquierda. Cuarto, los literales enteros se prueban contra el límite del entero seguro (-2^53+1 a 2^53-1); los valores fuera de este rango se mantienen como cadenas para evitar la pérdida de precisión IEEE 754. Quinto, las cadenas de fecha ISO 8601 se detectan por regex y se mantienen intencionalmente como cadenas — JSON no tiene un tipo de fecha nativo. Cualquier cosa que sobreviva a las cinco guardas se convierte mediante Number() (numérico) o se mantiene como cadena (todo lo demás).

Stripping de BOM y Gestión de Codificación

Toda la entrada se trata como UTF-8. El BOM UTF-8 opcional (0xEF 0xBB 0xBF) se elimina silenciosamente de la primera celda de la primera fila cuando está presente — esto evita que los bytes del BOM se incluyan como un carácter espurio al inicio del nombre de la primera columna (Excel en Windows comúnmente emite el BOM, rompiendo parsers ingenuos). Otras codificaciones (Windows-1252, ISO-8859-1) no se autodetectan; la API File del navegador ya habría decodificado los bytes como UTF-8 cuando el texto llega a esta herramienta. Si tienes entrada no UTF-8, conviértela primero con iconv o la opción de exportación de codificación de tu editor antes de pegar.

Buenas prácticas

Selecciona el Delimitador Explícitamente para Datos no Coma

No te fíes de la autodetección. Si tu CSV usa punto y coma (Excel-EU), tabulaciones (TSV de BigQuery, Snowflake o herramientas Unix) o pipes (campos con muchas comas), haz clic en el chip de Delimitador correspondiente antes de pegar. El parser es consciente del delimitador: cambiar el chip vuelve a analizar la entrada inmediatamente. Esto evita el modo de fallo CSV-a-JSON más común donde cada fila se colapsa en una sola celda porque el parser usó el separador equivocado.

Mantén Inferir Tipos Activado para JSON Tipado

Con Inferir tipos activado (predeterminado), obtienes JSON tipado: números como números, booleanos como booleanos, null donde aparecen celdas vacías. Esto es lo que la mayoría de consumidores quieren — APIs, frontends, código JavaScript. Desactiva Inferir tipos solo cuando necesites específicamente cada celda como cadena (consumidores posteriores con estrictez de tipos, pipelines de validación que comparan bytes exactos del origen). El pipeline de detección tiene guardas para cadenas con cero a la izquierda, enteros grandes y fechas ISO, así que los identificadores y las fechas permanecen seguros incluso con la inferencia activada.

Entrecomilla los IDs como Cadenas en el CSV de Origen

Si tu CSV es generado por una base de datos o pipeline que controlas, emite los IDs numéricos grandes (snowflakes de Twitter, IDs de Discord, resourceVersion de K8s) como cadenas CSV entrecomilladas ("9007199254740993") para que pasen por la inferencia de tipos limpiamente. El parser los mantendrá como cadenas de cualquier modo (la detección de enteros grandes captura valores por encima de 2^53 - 1), pero el entrecomillado explícito es el contrato aguas arriba más robusto y evita cualquier ambigüedad sobre la precisión.

La Fila de Cabecera Debe Ser la Primera Línea

Cabecera activada (predeterminado) autodetecta la primera fila como nombres de columna. Si tu CSV tiene comentarios, líneas en blanco o metadata antes de la cabecera, elimínalos antes de pegar — el parser no salta líneas no-datos iniciales. Para CSVs sin cabecera (exportaciones crudas, volcados generados por máquinas), desactiva Cabecera y las columnas se autonombrarán col1, col2, col3 en orden. No intentes falsificar una cabecera anteponiendo una a un archivo sin cabecera; o desactiva Cabecera o arregla el origen.

Usa Modo Stringify para Ida y Vuelta CSV → JSON → CSV

Si planeas hacer ida y vuelta de datos a través de ambas direcciones (CSV → JSON → CSV), la dirección inversa (JSON → CSV) necesita el modo Stringify para que cualquier array u objeto anidado sobreviva sin pérdidas. El modo Aplanar en la dirección inversa emite claves con puntos (customer.address.city) que no se pueden reconstruir perfectamente por el parser CSV. Consulta nuestro Convertidor JSON a CSV para la referencia completa de la dirección inversa y notas sobre tests de ida y vuelta.

Preguntas frecuentes