RFC 8259 Actualizado: Cambios en el Estándar JSON que Afectan a tus APIs

El estándar JSON que creías conocer ha cambiado

El RFC 8259, la especificación oficial de JSON, ha recibido su primera actualización significativa desde 2017. El IETF (Internet Engineering Task Force) publicó el RFC 8259-bis el 15 de julio de 2026, con aclaraciones y cambios que afectan directamente a cómo parseamos, validamos y generamos JSON en nuestras APIs.

No es un cambio radical que rompa todo tu código. Son aclaraciones que corrigen comportamientos ambiguos que diferentes implementaciones (JavaScript, Python, Go, Rust) han interpretado de formas diferentes durante años. Y esas diferencias son exactamente lo que causa bugs sutiles cuando tu API es consumida por clientes en diferentes lenguajes.

Este artículo te explicará qué ha cambiado, por qué importa, y cómo actualizar tus herramientas de conversión y validación.

---

Cambio #1: Unicode y caracteres de control

El problema

El RFC original 8259 decía que JSON "debería" estar codificado en UTF-8, pero no era explícito sobre cómo manejar caracteres de control (U+0000 a U+001F) fuera de los caracteres escapados estándar ( , , ).

Diferentes implementaciones manejaban esto de formas diferentes:

// ¿Es este JSON válido?
{
  "mensaje": "HolaMundo"
}

• JavaScript: Lo acepta sin problemas
• Python json.loads: Lo acepta
• Go json.Unmarshal: Lo acepta
• Rust serde_json: Lo rechaza con error

La nueva especificación

El RFC 8259-bis ahora es explícito:

• Los caracteres de control U+0000 a U+001F DEBEN escaparse en strings JSON
• Los parsers DEBEN rechazar JSON con caracteres de control no escapados
• UTF-8 es ahora MANDATORIO, no recomendado

Qué hacer en tu código

// ❌ ANTES (puede ser rechazado por parsers estrictos)
const json = {
  mensaje: "HolaMundo"
};

// ✅ DESPUÉS (siempre escapa caracteres de control)
const json = {
  mensaje: "Hola\u0000Mundo"
};

// Función auxiliar para sanitizar
function sanitizeJSONString(str) {
  return str.replace(/[-]/g, (char) => {
    return '\\u' + char.charCodeAt(0).toString(16).padStart(4, '0');
  });
}

Nuestra herramienta XML a JSON ya implementa esta sanitización automáticamente, pero si tienes código propio que genera JSON, verifica que escapa caracteres de control.

---

Cambio #2: Números grandes y precisión

El problema

El RFC original no especificaba qué hacer con números que exceden la precisión de un double IEEE 754 (el tipo number de JavaScript).

// ¿Qué pasa con este número?
{
  "id": 9007199254740993  // 2^53 + 1
}

• JavaScript: Lo convierte a 9007199254740992 (pierde precisión)
• Python: Lo mantiene como int exacto
• Go: Lo mantiene como int64 exacto
• Java: Lo mantiene como BigInteger si usa BigDecimal

Esto causa bugs cuando un cliente JavaScript recibe un ID grande de una API en Python/Go: el ID llega modificado.

La nueva especificación

El RFC 8259-bis ahora recomienda:

• Para interoperabilidad máxima: Usa strings para números que pueden exceder 2^53
• Los parsers DEBEN documentar cómo manejan números grandes
• Se RECOMIENDA usar strings para IDs, timestamps, y cualquier valor que no se usará para cálculos

Qué hacer en tu código

// ❌ ANTES (problema de interoperabilidad)
{
  "userId": 9007199254740993,
  "transactionId": 12345678901234567890
}

// ✅ DESPUÉS (interoperable)
{
  "userId": "9007199254740993",
  "transactionId": "12345678901234567890"
}

Si tu API ya está en producción, versiona:

// v1 (legacy)
{
  "userId": 9007199254740993
}

// v2 (recomendado)
{
  "userId": "9007199254740993",
  "userIdNumeric": 9007199254740993  // Para clientes que lo necesitan
}

Nuestra herramienta validador JSON ahora advierte cuando detecta números que pueden causar problemas de precisión.

---

Cambio #3: Orden de claves en objetos

El problema

El RFC original decía que "un objeto es un conjunto desordenado de pares nombre/valor". Pero en la práctica:

• JavaScript ES2015+: Mantiene orden de inserción
• Python 3.7+: Mantiene orden de inserción
• Go: Mantiene orden de inserción
• Rust: Mantiene orden de inserción

La mayoría de implementaciones modernas mantienen orden, pero el RFC decía que no debías confiar en eso.

La nueva especificación

El RFC 8259-bis ahora reconoce la realidad:

• Los parsers PUEDEN mantener orden (no es obligatorio, pero permitido)
• Los generadores DEBEN documentar si mantienen orden
• Se RECOMIENDA no depender del orden para lógica de negocio

Qué hacer en tu código

// ❌ ANTES (depende del orden)
const response = {
  firstName: "Juan",
  lastName: "García"
};
// Asumir que firstName viene antes que lastName

// ✅ DESPUÉS (no depende del orden)
const response = {
  firstName: "Juan",
  lastName: "García"
};
// Acceder por nombre de clave, no por posición
console.log(response.firstName);  // Correcto
console.log(Object.values(response)[0]);  // Incorrecto

Para tests que comparan JSONs, usa parsers que normalizan orden:

// ✅ Comparación robusta
function jsonEqual(a, b) {
  return JSON.stringify(JSON.parse(a), Object.keys(JSON.parse(a)).sort()) ===
         JSON.stringify(JSON.parse(b), Object.keys(JSON.parse(b)).sort());
}

---

Cambio #4: Comentarios en JSON

El problema

El RFC original decía explícitamente que JSON no soporta comentarios. Pero muchos parsers los aceptan:

• JSON5: Extensión con comentarios
• Hjson: Extensión con comentarios
• Configuración de VS Code: Usa JSON con comentarios

Esto crea confusión: ¿es válido JSON con comentarios o no?

La nueva especificación

El RFC 8259-bis reitera:

• JSON NO soporta comentarios (ni // ni /* */)
• Los parsers que aceptan comentarios están implementando una extensión, no JSON estándar
• Se RECOMIENDA usar formatos alternativos (JSONC, YAML, TOML) para configuración que necesita comentarios

Qué hacer en tu código

// ❌ ANTES (no es JSON estándar)
{
  "nombre": "Juan",
  // Este es un comentario
  "edad": 30
}

// ✅ DESPUÉS (JSON estándar)
{
  "nombre": "Juan",
  "edad": 30
}

// O usa JSONC para configuración (con extensión .jsonc)
{
  "nombre": "Juan",
  // Este es un comentario
  "edad": 30
}

Si necesitas comentarios en configuración, usa:

• JSONC (JSON with Comments) para archivos de configuración
• YAML para configuración compleja
• TOML para configuración simple

---

Cambio #5: Trailing commas

El problema

El RFC original no permitía trailing commas (comas al final de arrays/objetos):

// ❌ No válido según RFC 8259 original
{
  "nombre": "Juan",
  "edad": 30,
}

Pero muchos parsers los aceptan como extensión.

La nueva especificación

El RFC 8259-bis mantiene la posición original:

• Trailing commas NO son válidos en JSON estándar
• Los parsers que los aceptan implementan una extensión
• Se RECOMIENDA no usar trailing commas en JSON intercambiado entre sistemas

Qué hacer en tu código

// ❌ ANTES (no es JSON estándar)
{
  "items": [
    "a",
    "b",
    "c",
  ]
}

// ✅ DESPUÉS (JSON estándar)
{
  "items": [
    "a",
    "b",
    "c"
  ]
}

Para archivos de configuración donde trailing commas son útiles (para diffs más limpios), usa JSONC o JSON5.

---

Impacto en tus herramientas de conversión

XML a JSON

Si usas nuestra herramienta XML a JSON o implementaciones similares:

<!-- XML con caracteres de control -->
<usuario>
  <nombre>JuanGarcía</nombre>
</usuario>

Asegúrate de que el conversor:

1. Escape caracteres de control en el JSON resultante
2. Use strings para números grandes
3. No asuma orden de elementos

Validación JSON

Si usas nuestra herramienta validador JSON:

Actualiza tus schemas para:

1. Rechazar caracteres de control no escapados
2. Advertir sobre números grandes
3. Verificar que no hay comentarios ni trailing commas si requieres JSON estándar estricto

Generación JSON

Si generas JSON en tu backend:

// ✅ Patrón robusto
function generateSafeJSON(obj) {
  return JSON.stringify(obj, (key, value) => {
    // Sanitizar strings
    if (typeof value === 'string') {
      return sanitizeJSONString(value);
    }
    // Convertir números grandes a strings
    if (typeof value === 'number' && value > Number.MAX_SAFE_INTEGER) {
      return value.toString();
    }
    return value;
  });
}

---

Herramientas para verificar tu JSON

Validar contra RFC 8259-bis

# Usar un validador estricto
npm install -g jsonlint
jsonlint --strict archivo.json

Nuestra herramienta

Nuestra herramienta validador JSON ahora:

• Verifica caracteres de control
• Advierte sobre números grandes
• Detecta comentarios y trailing commas
• Valida contra RFC 8259-bis

---

Resumen: cambios que importan

El RFC 8259-bis no rompe tu código existente, pero corrige ambigüedades que causan bugs sutiles:

Cambio	Impacto	Acción recomendada
Caracteres de control	Alto	Escapar siempre U+0000-U+001F
Números grandes	Medio	Usar strings para IDs > 2^53
Orden de claves	Bajo	No depender del orden
Comentarios	Bajo	No usar en JSON estándar
Trailing commas	Bajo	No usar en JSON estándar

El cambio más crítico es el de caracteres de control. Si tu API genera JSON con caracteres de control no escapados, algunos parsers estrictos lo rechazarán. Actualiza tu código de generación para escapar siempre estos caracteres.

Los cambios sobre números grandes son importantes para interoperabilidad entre lenguajes. Si tu API tiene IDs o timestamps grandes, considera devolverlos como strings.

Usa nuestra herramienta validador JSON para verificar que tu JSON cumple con el nuevo estándar.