Convertir JSON a Excel: Guía Completa con Python, JavaScript y Herramientas

# Convertir JSON a Excel: Guía Completa con Python, JavaScript y Herramientas

Convertir datos JSON a archivos Excel es una necesidad común en análisis de datos y reportes. Esta guía completa te enseñará múltiples métodos para realizar esta conversión eficientemente.

¿Por Qué Convertir JSON a Excel?

Casos de Uso Comunes

• Reportes de negocio - Compartir datos con stakeholders
• Análisis de datos - Usar características de Excel para análisis
• Importación de datos - Migrar datos entre sistemas
• Visualización - Crear gráficos y tablas dinámicas
• Archivo - Almacenar datos en formato universalmente accesible

Método 1: Python con pandas

Instalación

pip install pandas openpyxl

Conversión Básica

import pandas as pd
import json

# Leer archivo JSON
with open('datos.json', 'r', encoding='utf-8') as f:
    datos = json.load(f)

# Convertir a DataFrame
df = pd.DataFrame(datos)

# Guardar como Excel
df.to_excel('salida.xlsx', index=False, sheet_name='Datos')

print("Conversión completada!")

Ejemplo con Datos de Usuarios

import pandas as pd
import json

# JSON de ejemplo
json_data = '''
[
  {
    "id": 1,
    "nombre": "Ana García",
    "email": "ana@ejemplo.com",
    "edad": 28,
    "departamento": "Ventas"
  },
  {
    "id": 2,
    "nombre": "Carlos López",
    "email": "carlos@ejemplo.com",
    "edad": 35,
    "departamento": "Ingeniería"
  },
  {
    "id": 3,
    "nombre": "María Rodríguez",
    "email": "maria@ejemplo.com",
    "edad": 31,
    "departamento": "Marketing"
  }
]
'''

# Parsear JSON
datos = json.loads(json_data)

# Crear DataFrame
df = pd.DataFrame(datos)

# Guardar a Excel
df.to_excel('usuarios.xlsx', index=False, engine='openpyxl')

JSON Anidado

import pandas as pd
import json

# JSON con estructura anidada
json_data = '''
[
  {
    "id": 1,
    "nombre": "Ana",
    "contacto": {
      "email": "ana@ejemplo.com",
      "telefono": "+34600111222"
    },
    "habilidades": ["Python", "SQL", "Excel"]
  },
  {
    "id": 2,
    "nombre": "Carlos",
    "contacto": {
      "email": "carlos@ejemplo.com",
      "telefono": "+34600333444"
    },
    "habilidades": ["JavaScript", "React", "Node.js"]
  }
]
'''

datos = json.loads(json_data)

# Normalizar datos anidados
df = pd.json_normalize(datos)

# Guardar a Excel
df.to_excel('usuarios_normalizado.xlsx', index=False)

# El resultado tendrá columnas:
# id, nombre, contacto.email, contacto.telefono, habilidades

Múltiples Hojas

import pandas as pd
import json

# Datos para diferentes hojas
usuarios = [
    {"id": 1, "nombre": "Ana", "edad": 28},
    {"id": 2, "nombre": "Carlos", "edad": 35}
]

ventas = [
    {"producto": "Portátil", "cantidad": 5, "precio": 999.99},
    {"producto": "Ratón", "cantidad": 20, "precio": 29.99}
]

# Crear archivo Excel con múltiples hojas
with pd.ExcelWriter('reporte.xlsx', engine='openpyxl') as writer:
    pd.DataFrame(usuarios).to_excel(writer, sheet_name='Usuarios', index=False)
    pd.DataFrame(ventas).to_excel(writer, sheet_name='Ventas', index=False)

print("Excel con múltiples hojas creado!")

Formateo Avanzado

import pandas as pd
from openpyxl import load_workbook
from openpyxl.styles import Font, PatternFill, Alignment

# Crear DataFrame y guardar
df = pd.DataFrame({
    'Producto': ['Portátil', 'Ratón', 'Teclado'],
    'Precio': [999.99, 29.99, 79.99],
    'Stock': [50, 200, 150]
})

archivo = 'productos_formateado.xlsx'
df.to_excel(archivo, index=False, sheet_name='Productos')

# Cargar y formatear
wb = load_workbook(archivo)
ws = wb['Productos']

# Formatear encabezados
header_fill = PatternFill(start_color='4472C4', end_color='4472C4', fill_type='solid')
header_font = Font(color='FFFFFF', bold=True)

for cell in ws[1]:
    cell.fill = header_fill
    cell.font = header_font
    cell.alignment = Alignment(horizontal='center')

# Ajustar ancho de columnas
for column in ws.columns:
    max_length = 0
    column_letter = column[0].column_letter
    for cell in column:
        if cell.value:
            max_length = max(max_length, len(str(cell.value)))
    ws.column_dimensions[column_letter].width = max_length + 2

# Guardar cambios
wb.save(archivo)
print("Excel formateado guardado!")

Método 2: JavaScript/Node.js con xlsx

Instalación

npm install xlsx

Conversión Básica

const XLSX = require('xlsx');
const fs = require('fs');

// Leer archivo JSON
const jsonData = JSON.parse(fs.readFileSync('datos.json', 'utf8'));

// Crear workbook
const workbook = XLSX.utils.book_new();

// Convertir JSON a hoja
const worksheet = XLSX.utils.json_to_sheet(jsonData);

// Añadir hoja al workbook
XLSX.utils.book_append_sheet(workbook, worksheet, 'Datos');

// Escribir archivo Excel
XLSX.writeFile(workbook, 'salida.xlsx');

console.log('Conversión completada!');

Ejemplo Completo

const XLSX = require('xlsx');

// Datos de ejemplo
const usuarios = [
  {
    id: 1,
    nombre: 'Ana García',
    email: 'ana@ejemplo.com',
    edad: 28,
    activo: true
  },
  {
    id: 2,
    nombre: 'Carlos López',
    email: 'carlos@ejemplo.com',
    edad: 35,
    activo: true
  },
  {
    id: 3,
    nombre: 'María Rodríguez',
    email: 'maria@ejemplo.com',
    edad: 31,
    activo: false
  }
];

// Crear workbook
const wb = XLSX.utils.book_new();

// Crear hoja desde JSON
const ws = XLSX.utils.json_to_sheet(usuarios);

// Añadir hoja
XLSX.utils.book_append_sheet(wb, ws, 'Usuarios');

// Guardar archivo
XLSX.writeFile(wb, 'usuarios.xlsx');

Múltiples Hojas

const XLSX = require('xlsx');

// Diferentes conjuntos de datos
const usuarios = [
  { id: 1, nombre: 'Ana', departamento: 'Ventas' },
  { id: 2, nombre: 'Carlos', departamento: 'IT' }
];

const ventas = [
  { mes: 'Enero', monto: 15000 },
  { mes: 'Febrero', monto: 18000 }
];

// Crear workbook
const wb = XLSX.utils.book_new();

// Añadir múltiples hojas
XLSX.utils.book_append_sheet(
  wb,
  XLSX.utils.json_to_sheet(usuarios),
  'Usuarios'
);

XLSX.utils.book_append_sheet(
  wb,
  XLSX.utils.json_to_sheet(ventas),
  'Ventas'
);

// Guardar
XLSX.writeFile(wb, 'reporte_completo.xlsx');

Encabezados Personalizados

const XLSX = require('xlsx');

const datos = [
  { name: 'Ana', age: 28, dept: 'Sales' },
  { name: 'Carlos', age: 35, dept: 'IT' }
];

// Mapeo de encabezados personalizados
const headers = {
  name: 'Nombre',
  age: 'Edad',
  dept: 'Departamento'
};

// Crear hoja con encabezados personalizados
const ws = XLSX.utils.json_to_sheet(datos, {
  header: Object.keys(headers)
});

// Reemplazar encabezados
XLSX.utils.sheet_add_aoa(ws, [Object.values(headers)], { origin: 'A1' });

const wb = XLSX.utils.book_new();
XLSX.utils.book_append_sheet(wb, ws, 'Datos');
XLSX.writeFile(wb, 'personalizado.xlsx');

Formateo de Celdas

const XLSX = require('xlsx');

const datos = [
  { producto: 'Portátil', precio: 999.99, fecha: new Date('2024-01-15') },
  { producto: 'Ratón', precio: 29.99, fecha: new Date('2024-01-16') }
];

const ws = XLSX.utils.json_to_sheet(datos);

// Formatear columnas
const range = XLSX.utils.decode_range(ws['!ref']);

for (let R = range.s.r + 1; R <= range.e.r; ++R) {
  // Formatear precios (columna B)
  const price_cell_address = XLSX.utils.encode_cell({ r: R, c: 1 });
  if (!ws[price_cell_address]) continue;
  ws[price_cell_address].z = '€#,##0.00';

  // Formatear fechas (columna C)
  const date_cell_address = XLSX.utils.encode_cell({ r: R, c: 2 });
  if (!ws[date_cell_address]) continue;
  ws[date_cell_address].z = 'dd/mm/yyyy';
}

const wb = XLSX.utils.book_new();
XLSX.utils.book_append_sheet(wb, ws, 'Productos');
XLSX.writeFile(wb, 'formateado.xlsx');

Método 3: Herramientas Online

Usando Big JSON Viewer

Visita bigjson.online

Carga tu archivo JSON

Usa la opción de exportar a Excel

Descarga el archivo generado

Ventajas:

• Sin instalación necesaria
• Maneja archivos grandes
• Interfaz intuitiva
• Procesamiento local (privado)

Otras Herramientas Online

ConvertJSON.com

• Pega JSON, descarga Excel
• Límite de tamaño: ~5MB
• Gratuito

JSON-to-Excel.com

• Conversión simple
• Soporte básico para anidación
• Sin registro requerido

Método 4: Línea de Comandos con jq

Convertir JSON a CSV (luego a Excel)

# Instalar jq
# Ubuntu/Debian: apt-get install jq
# macOS: brew install jq
# Windows: descarga desde stedolan.github.io/jq

# Convertir JSON a CSV
jq -r '.[] | [.id, .nombre, .email] | @csv' usuarios.json > usuarios.csv

# Luego abrir CSV en Excel o convertir con Python

Script Bash Completo

#!/bin/bash

# json_to_excel.sh
JSON_FILE=$1
OUTPUT_FILE="${JSON_FILE%.json}.xlsx"

# Convertir a CSV temporal
jq -r '
  (.[0] | keys_unsorted) as $keys |
  $keys,
  (.[] | [.[$keys[]]] | @csv)
' "$JSON_FILE" > temp.csv

# Convertir CSV a Excel usando Python
python3 << EOF
import pandas as pd
df = pd.read_csv('temp.csv')
df.to_excel('$OUTPUT_FILE', index=False)
print('Convertido a $OUTPUT_FILE')
EOF

rm temp.csv

Manejo de Estructuras Complejas

JSON con Arrays Anidados

import pandas as pd
import json

json_data = '''
[
  {
    "id": 1,
    "nombre": "Ana",
    "pedidos": [
      {"producto": "Portátil", "precio": 999},
      {"producto": "Ratón", "precio": 29}
    ]
  },
  {
    "id": 2,
    "nombre": "Carlos",
    "pedidos": [
      {"producto": "Teclado", "precio": 79}
    ]
  }
]
'''

datos = json.loads(json_data)

# Estrategia 1: Expandir arrays a filas
filas = []
for usuario in datos:
    for pedido in usuario['pedidos']:
        filas.append({
            'usuario_id': usuario['id'],
            'nombre': usuario['nombre'],
            'producto': pedido['producto'],
            'precio': pedido['precio']
        })

df = pd.DataFrame(filas)
df.to_excel('pedidos_expandidos.xlsx', index=False)

# Estrategia 2: Convertir arrays a strings
for usuario in datos:
    usuario['pedidos'] = ', '.join([p['producto'] for p in usuario['pedidos']])

df2 = pd.DataFrame(datos)
df2.to_excel('pedidos_concatenados.xlsx', index=False)

JSON Profundamente Anidado

import pandas as pd
import json

json_data = '''
{
  "empresa": {
    "nombre": "TechCorp",
    "departamentos": {
      "ingenieria": {
        "empleados": [
          {"nombre": "Ana", "salario": 60000},
          {"nombre": "Carlos", "salario": 65000}
        ]
      },
      "ventas": {
        "empleados": [
          {"nombre": "María", "salario": 55000}
        ]
      }
    }
  }
}
'''

datos = json.loads(json_data)

# Aplanar estructura
filas = []
empresa = datos['empresa']
for dept_nombre, dept_data in empresa['departamentos'].items():
    for empleado in dept_data['empleados']:
        filas.append({
            'empresa': empresa['nombre'],
            'departamento': dept_nombre,
            'empleado': empleado['nombre'],
            'salario': empleado['salario']
        })

df = pd.DataFrame(filas)
df.to_excel('estructura_aplanada.xlsx', index=False)

Mejores Prácticas

1. Validar JSON Antes de Convertir

import json
import pandas as pd

def json_a_excel_seguro(archivo_json, archivo_excel):
    try:
        # Validar JSON
        with open(archivo_json, 'r', encoding='utf-8') as f:
            datos = json.load(f)

        # Verificar que sea lista o dict
        if not isinstance(datos, (list, dict)):
            raise ValueError("JSON debe ser lista u objeto")

        # Convertir
        if isinstance(datos, list):
            df = pd.DataFrame(datos)
        else:
            df = pd.DataFrame([datos])

        # Guardar
        df.to_excel(archivo_excel, index=False)
        print(f"✓ Convertido exitosamente a {archivo_excel}")

    except json.JSONDecodeError as e:
        print(f"✗ Error de JSON: {e}")
    except Exception as e:
        print(f"✗ Error: {e}")

# Uso
json_a_excel_seguro('datos.json', 'salida.xlsx')

2. Manejar Datos Faltantes

import pandas as pd

# JSON con datos inconsistentes
datos = [
    {"nombre": "Ana", "edad": 28, "ciudad": "Madrid"},
    {"nombre": "Carlos", "edad": 35},  # ciudad faltante
    {"nombre": "María", "ciudad": "Barcelona"}  # edad faltante
]

df = pd.DataFrame(datos)

# Rellenar valores faltantes
df['edad'].fillna(0, inplace=True)
df['ciudad'].fillna('No especificada', inplace=True)

df.to_excel('datos_completos.xlsx', index=False)

3. Optimizar para Archivos Grandes

import pandas as pd
import json

def convertir_json_grande(archivo_json, archivo_excel, tamaño_fragmento=10000):
    """Convertir JSON grande en fragmentos"""

    # Leer JSON
    with open(archivo_json, 'r', encoding='utf-8') as f:
        datos = json.load(f)

    # Procesar en fragmentos
    with pd.ExcelWriter(archivo_excel, engine='openpyxl') as writer:
        for i in range(0, len(datos), tamaño_fragmento):
            fragmento = datos[i:i + tamaño_fragmento]
            df = pd.DataFrame(fragmento)

            # Escribir a diferentes hojas si es necesario
            nombre_hoja = f'Datos_{i//tamaño_fragmento + 1}'
            df.to_excel(writer, sheet_name=nombre_hoja, index=False)

    print(f"Convertidos {len(datos)} registros")

# Uso
convertir_json_grande('datos_grandes.json', 'salida.xlsx')

4. Preservar Tipos de Datos

import pandas as pd
from datetime import datetime

datos = [
    {
        "fecha": "2024-01-15",
        "monto": "999.99",
        "cantidad": "5"
    }
]

df = pd.DataFrame(datos)

# Convertir tipos
df['fecha'] = pd.to_datetime(df['fecha'])
df['monto'] = df['monto'].astype(float)
df['cantidad'] = df['cantidad'].astype(int)

# Guardar con tipos correctos
df.to_excel('tipos_correctos.xlsx', index=False)

Casos de Uso Avanzados

Crear Informe con Fórmulas

import pandas as pd
from openpyxl import load_workbook

# Datos de ventas
ventas = [
    {"producto": "Portátil", "cantidad": 5, "precio_unitario": 999.99},
    {"producto": "Ratón", "cantidad": 20, "precio_unitario": 29.99},
    {"producto": "Teclado", "cantidad": 15, "precio_unitario": 79.99}
]

df = pd.DataFrame(ventas)
archivo = 'informe_ventas.xlsx'
df.to_excel(archivo, index=False, startrow=1)

# Añadir fórmulas
wb = load_workbook(archivo)
ws = wb.active

# Añadir título
ws['A1'] = 'Informe de Ventas'

# Añadir columna de total con fórmulas
ws['D1'] = 'Total'
for i in range(2, len(ventas) + 2):
    ws[f'D{i}'] = f'=B{i}*C{i}'

# Añadir suma total
ultima_fila = len(ventas) + 2
ws[f'C{ultima_fila}'] = 'TOTAL:'
ws[f'D{ultima_fila}'] = f'=SUM(D2:D{ultima_fila-1})'

wb.save(archivo)
print("Informe con fórmulas creado!")

Conclusión

Convertir JSON a Excel es una tarea común que puede realizarse de múltiples formas. Python con pandas ofrece la solución más flexible y potente, mientras que las herramientas online como Big JSON Viewer proporcionan conveniencia para conversiones rápidas.

Recomendaciones

• Para proyectos Python: Usa pandas + openpyxl
• Para proyectos Node.js: Usa biblioteca xlsx
• Para conversiones rápidas: Usa Big JSON Viewer
• Para automatización: Crea scripts reutilizables
• Para archivos grandes: Procesa en fragmentos

¡Comienza a convertir tus datos JSON a Excel hoy mismo!