ToolActToolAct

Convertidor de CSV a JSON

Sube un archivo CSV o pega los datos para convertir a formato JSON

Arrastra el archivo CSV aquí, o haz clic para seleccionar

¿Qué es CSV a JSON?

CSV a JSON es una herramienta en línea de conversión de formatos de datos que convierte datos CSV (valores separados por comas) al formato JSON (notación de objetos JavaScript).

CSV es un formato de datos tabulares común, ampliamente utilizado en hojas de cálculo y exportaciones de bases de datos. JSON es el formato de intercambio de datos más popular en las aplicaciones web modernas, conocido por su estructura clara y fácil análisis.

Con esta herramienta, puedes convertir rápidamente datos CSV en arrays u objetos JSON para usar en programación y procesamiento de datos.

Cómo usar

Cómo usar

  1. Pega o escribe los datos CSV en el panel de entrada izquierdo
  2. Selecciona el delimitador adecuado (la coma es el predeterminado)
  3. Elige si usar la primera fila como nombres de campos
  4. El panel derecho generará automáticamente el resultado JSON

Notas de análisis CSV

  • Verifica el delimitador, el manejo de comillas y la configuración de la fila de encabezado antes de confiar en la salida JSON.
  • Los archivos CSV grandes pueden contener filas en blanco, comas incrustadas o saltos de línea dentro de celdas entrecomilladas; previsualiza algunas filas tras la conversión.

Casos de uso

Convertir archivos CSV o TSV subidos en arrays JSONArrastra o selecciona un archivo .csv, .tsv o .txt, elige coma, tabulación, punto y coma o barra vertical como delimitador, y decide si la primera fila debe convertirse en claves de objeto o si la salida debe mantenerse como arrays. El archivo se lee en el navegador con FileReader, se analiza localmente con un tokenizador de flujo y nunca se sube, por lo que las exportaciones de clientes o datos internos nunca abandonan el dispositivo.
Previsualizar el conteo de filas y campos antes de usar el JSONUsa el nombre de archivo mostrado, el conteo de filas, el conteo de campos y la salida JSON resaltada para detectar errores de delimitador, encabezados faltantes o filas vacías antes de copiar en mocks o scripts. Funciona bien como paso intermedio controlado: pega la salida en el destino real y verifica que el sistema receptor la interprete de la misma manera.
Procesar CSV entrecomillado simple sin salir del navegadorEl analizador soporta campos entrecomillados, comillas dobles escapadas y los cuatro delimitadores comunes, lo que lo hace adecuado para exportaciones pequeñas y datos de prueba. Los archivos se procesan completamente en la memoria del navegador, así que incluso capturas sensibles de RR. HH., finanzas o staging pueden reestructurarse sin enviar los datos por la red.
Preservar información de tipos al enviar JSON a una API tipadaTras la conversión, revisa la salida en busca de campos que deberían ser números, booleanos, fechas o nulos en lugar de cadenas, y post-procesa el array antes de enviarlo a endpoints REST o GraphQL. CSV no tiene tipos nativos, así que un vistazo rápido a las primeras filas suele bastar para detectar IDs entrecomillados y códigos con ceros a la izquierda.
Detectar filas mal formadas antes de subirlas a mocks o fixturesUsa el conteo de filas/campos y los errores de análisis para marcar líneas que no coinciden con el número esperado de columnas, y corrige el CSV de origen en lugar de dejar que filas defectuosas se filtren en el JSON de prueba. El panel de vista previa se detiene en la primera fila inconsistente para que puedas corregir el delimitador o añadir una comilla faltante antes de volver a ejecutar.

Principio técnico

El análisis CSV sigue la gramática del RFC 4180 del IETF: cada registro termina con CRLF (algunos dialectos aceptan LF o CR), cada registro contiene campos separados por un delimitador (coma en el RFC, pero TSV, punto y coma y barra vertical son variantes extendidas), y cualquier campo que contenga el delimitador, un CR, un LF o una comilla doble DEBE estar entre comillas dobles, con las comillas internas escapadas mediante duplicación (Hello "world" se convierte en "Hello ""world"""). El analizador de esta página es una máquina de estados con cuatro estados: field_start, in_unquoted, in_quoted, after_quote, y procesa la entrada en una sola pasada O(n) sobre el flujo de caracteres, de modo que un CSV de 10 MB con 100.000 filas se completa en mucho menos de un segundo en un portátil típico sin asignar nunca un array intermedio de tokens por fila. La codificación requiere manejo explícito: un BOM UTF-8 (EF BB BF) al inicio del archivo se elimina antes del análisis, de lo contrario el primer nombre de encabezado comenzaría silenciosamente con el punto de código invisible U+FEFF y las comprobaciones de igualdad de JSON.parse aguas abajo fallarían. Las exportaciones de Excel en Windows aún emiten CRLF y frecuentemente UTF-8 con BOM, mientras que Numbers de macOS y la mayoría de herramientas Unix usan por defecto LF sin BOM. Las hojas de cálculo europeas comúnmente exportan archivos delimitados por punto y coma porque la coma es un separador decimal en muchos locales (49,90 EUR en lugar de 49.90), por lo que el selector de delimitador tiene la coma como valor predeterminado pero expone tabulación, punto y coma y barra vertical como opciones de primera clase. El interruptor de primera fila como encabezado cambia la forma de salida de un array de objetos (claves de encabezado -> valores string) a un array de arrays, coincidiendo con los dos patrones de ingestión más comunes para el código aguas abajo. Los valores de campo se emiten como cadenas, no como tipos inferidos: CSV no tiene esquema, por lo que 01234 (un ID con ceros a la izquierda), 1e10 (una cadena con apariencia de número de teléfono que JSON.parse convertiría a número) y 2024-13-45 (una fecha mal formada) permanecen tal cual. Esto es intencional: una API tipada aguas abajo puede aplicar zod, Joi o una capa de coerción manual con reglas explícitas, pero no puede recuperar un cero inicial que el convertidor ya haya eliminado. La salida se genera mediante JSON.stringify(rows, null, 2) y se renderiza a través de un resaltador de sintaxis; el CSV fuente se lee con FileReader.readAsText() en un Blob, sin subirse nunca a un backend, por lo que las exportaciones de RR. HH., libros de contabilidad y listas de clientes pueden reestructurarse sin salir de la sesión del navegador.

  • Gramática RFC 4180: los campos con delimitador/CR/LF/comilla deben ir entrecomillados; las comillas internas se duplican como "".
  • Máquina de estados en una sola pasada O(n) con estados: field_start, in_unquoted, in_quoted, after_quote.
  • El BOM UTF-8 (EF BB BF / U+FEFF) se elimina al inicio del archivo para mantener limpias las claves de encabezado.
  • Las hojas de cálculo europeas suelen usar ; como delimitador porque la coma es el separador decimal en la configuración regional.
  • La primera fila como encabezado alterna la salida entre Array<Record<string,string>> y Array<Array<string>>.
  • Todos los valores de campo permanecen como cadenas; los IDs con ceros a la izquierda como 01234 sobreviven solo porque no se ejecuta inferencia de tipos.
  • FileReader.readAsText() procesa el Blob localmente; nada se sube - seguro para exportaciones de RR. HH./finanzas/staging.

Ejemplos

CSV básico con fila de encabezado -> array JSON de objetos

Entrada CSV:
name,age,city
Alice,28,New York
Bob,35,London
Carol,42,Tokyo

Salida JSON:
[
  { "name": "Alice", "age": "28", "city": "New York" },
  { "name": "Bob",   "age": "35", "city": "London"   },
  { "name": "Carol", "age": "42", "city": "Tokyo"    }
]

Campos entre comillas con comas incrustadas

Entrada CSV:
id,product,description
1,"Notebook, A5","Hard cover, 200 pages"
2,Pen,"Black ink, 0.5mm"

Salida JSON:
[
  { "id": "1", "product": "Notebook, A5", "description": "Hard cover, 200 pages" },
  { "id": "2", "product": "Pen",          "description": "Black ink, 0.5mm" }
]

TSV (delimitado por tabulaciones) sin encabezado

Entrada TSV (delimitador = Tab, encabezado desactivado):
101	Alice	98.5
102	Bob	87.0
103	Carol	92.3

Salida JSON:
[
  ["101", "Alice", "98.5"],
  ["102", "Bob",   "87.0"],
  ["103", "Carol", "92.3"]
]

Delimitador punto y coma (exportaciones europeas de hojas de cálculo)

Entrada CSV (delimitador = ;):
product;price_eur;stock
Keyboard;49,90;120
Mouse;19,90;345

Salida JSON:
[
  { "product": "Keyboard", "price_eur": "49,90", "stock": "120" },
  { "product": "Mouse",    "price_eur": "19,90", "stock": "345" }
]
Nota: los números permanecen como cadenas - conviértelos en tu código posterior.

Preguntas frecuentes

¿Qué variantes de CSV son compatibles?

CSV estándar RFC 4180: separador por coma, comillas dobles para campos y comillas dobles repetidas para escapar. Los formatos separados por tabuladores (TSV) o por punto y coma funcionan cambiando el separador. Los distintos finales de línea (LF/CRLF/CR) se gestionan automáticamente.

¿Cómo se gestionan las cabeceras?

Si activas «la primera fila es cabecera», el parser usa cada celda de la cabecera como clave JSON de esa columna y produce un array de objetos. Sin cabeceras, el parser produce un array de arrays. Las celdas de cabecera vacías reciben una clave numérica como sustituto.

¿Cómo se infieren los tipos?

Por defecto todo es string. Activa «tipo automático» para intentar parsear números, booleanos (true/false) y null. Los números con ceros a la izquierda (00123, 0042) se quedan como strings para no perder el prefijo: úsalo para IDs y códigos postales.

¿Qué pasa si un campo contiene una coma o un salto de línea?

Envuelve el campo entre comillas dobles: "Smith, John" o "línea uno\nlínea dos". Las comillas dobles internas se duplican: "He said ""hi""". El parser maneja todos estos casos; si una fila se rompe, la causa suele ser comillas desequilibradas.

¿La conversión se hace en local o en un servidor?

En local. El parseo se ejecuta en tu navegador con JavaScript. El CSV pegado no sale de la página. Los archivos grandes pueden ralentizar el navegador; si el contenido pegado supera decenas de MB, divídelo antes de procesarlo.

¿Se preserva el orden de las columnas?

Sí: cada fila se convierte en un objeto JSON cuyo orden de claves coincide con el de la cabecera del CSV, y JSON.stringify en los motores modernos preserva el orden de inserción. Si tu herramienta posterior lee JSON sin preservar el orden de inserción, esa es su limitación.

¿Cómo manejo las fechas?

Las fechas se quedan como strings. El tipado automático no parsea formatos de fecha arbitrarios porque no existe un estándar inequívoco (1/2/2024 es 2 de enero en EE. UU. y 1 de febrero en Europa). Convierte las fechas a ISO 8601 (YYYY-MM-DD) antes de importarlas si necesitas objetos Date nativos en destino.