Coma final en JSON: por qué falla y cómo eliminarla (RFC 8259)

Coma final en JSON — la respuesta breve

Una coma final es la coma que queda tras el último elemento de un objeto o un array, justo antes del cierre } o ]. El JSON estándar (RFC 8259) no la permite, así que un analizador estricto rechaza el archivo con un error como Unexpected token } o Expecting property name enclosed in double quotes. La solución es borrar esa coma.

Esta página trata sobre comas finales (,), no sobre comentarios // o /* */. Si en realidad querías comentarios en JSON, ese es otro tema y lo cubre ¿Se permiten comentarios en JSON?. Aquí nos centramos en la coma sobrante: por qué da error, cómo encontrarla, cómo eliminarla y en qué se diferencian los supersets JSON5 y JSONC.

Corrígelo ahora en tu navegador

Si solo quieres que desaparezca el error, no hace falta contar caracteres a mano:

1. Abre el formateador de JSON
2. Pega el JSON que está fallando
3. Lee la línea del error: apunta al corchete de cierre que sigue a la coma sobrante
4. Borra la coma justo antes de ese } o ] y pulsa Run de nuevo
5. Copia el JSON limpio y formateado de la salida

El formateador se ejecuta por completo en tu navegador. El JSON que pegas nunca se sube, ni se registra, ni se guarda, lo cual importa cuando el contenido es una respuesta de API o un archivo de configuración con datos internos.

Antes y después

Una coma final puede aparecer en tres lugares. Aquí tienes cada caso roto junto a su corrección.

Coma final en un objeto:

{
  "name": "Aoi",
  "role": "Engineer",
}

{
  "name": "Aoi",
  "role": "Engineer"
}

Coma final en un array:

[
  "red",
  "green",
  "blue",
]

[
  "red",
  "green",
  "blue"
]

Anidada: una coma final puede esconderse dentro de un objeto o array interno:

{
  "tags": ["a", "b",],
  "meta": {
    "active": true,
  }
}

{
  "tags": ["a", "b"],
  "meta": {
    "active": true
  }
}

En todos los casos la corrección es la misma: eliminar la coma que queda entre el último valor y el corchete de cierre. Los valores en sí están bien.

Los mensajes de error que verás

Cada analizador describe la misma coma final de forma distinta, así que el texto depende del lenguaje que lea el archivo.

Navegador y Node.js (V8) JSON.parse:

SyntaxError: Unexpected token } in JSON at position 42

SyntaxError: Expected double-quoted property name in JSON at position 42

Python json.loads:

json.decoder.JSONDecodeError: Expecting property name enclosed in double quotes: line 4 column 1 (char 42)

El hilo común es que el analizador llega a la coma, espera otro valor o clave después y, en su lugar, encuentra un corchete de cierre. La posición o el número de línea que informa corresponde al cierre } o ], así que la coma a borrar está en la línea anterior. Si ves uno de estos mensajes pero no encuentras la coma, pega el archivo en el formateador de JSON y te marcará la línea. Para la lista completa de causas de errores de análisis (comillas simples, claves sin comillas, comas faltantes), consulta Cómo corregir errores de análisis de JSON.

Por qué JSON prohíbe las comas finales

Según RFC 8259, una coma es un separador entre valores, no un terminador tras cada valor. La gramática de la Sección 2 define un array como valores separados por comas y un objeto como miembros separados por comas: no hay regla de producción que permita un elemento tras el último valor. Por eso una coma seguida solo de espacios y un corchete de cierre no tiene nada que separar, y un analizador conforme debe rechazarla.

También por eso el error es tan frecuente: los literales de objeto y array de JavaScript sí permiten comas finales, y muchos editores formatean los archivos .js así. Pero JSON.parse() lee JSON estricto, no JavaScript, de modo que el mismo texto que funciona dentro de un archivo .js falla en cuanto se analiza como JSON. Copiar un objeto del código a un archivo .json es la forma clásica en que se cuela una coma final.

Para el resto de las reglas del JSON estricto, consulta la guía de sintaxis de JSON.

Elimina las comas finales automáticamente

Borrar una coma a mano es rápido. Cuando generas JSON o limpias muchos archivos, automatízalo.

Genera JSON con un serializador, no con concatenación de cadenas. JSON.stringify (y su equivalente en cada lenguaje) nunca emite una coma final, así que el problema no puede ocurrir:

const data = { name: "Aoi", role: "Engineer" };
const json = JSON.stringify(data, null, 2);
// siempre válido — nunca se produce una coma final

Formatea al guardar. En VS Code, ejecutar Format Document (o Prettier con format-on-save) sobre un archivo .json elimina las comas finales como parte del reformateo. Es la forma más sencilla de mantener limpios los archivos de configuración editados a mano.

Una expresión regular es el último recurso. El patrón ,\s*([}\]]) coincide con una coma seguida de espacios y un corchete de cierre:

const cleaned = source.replace(/,(\s*[}\]])/g, "$1");
const data = JSON.parse(cleaned);

Trátala solo como respaldo. Puede fallar con una coma que aparezca dentro de un valor de cadena (por ejemplo "a,}"), así que úsala solo en archivos que controles y valida el resultado en el formateador de JSON después.

Las opciones del analizador aceptan, no reescriben. Algunas librerías toleran comas finales (JsonSerializerOptions.AllowTrailingCommas de .NET, entre otras). Eso permite que tu código lea el archivo, pero no cambia el archivo en disco ni lo hace válido para otro analizador estricto. Si el JSON debe viajar a otro servicio, sigues necesitando eliminar la coma.

Evita que las comas finales vuelvan

Corregir el archivo una vez no detiene el siguiente. Un par de salvaguardas las detectan pronto:

• Editor: VS Code marca las comas finales en archivos .json (no en .jsonc). Mantén la extensión .json para que el aviso siga activo
• Linting y CI: un linter que entienda JSON, o un paso de JSON.parse en tu build, hará fallar el commit antes de que el archivo roto llegue a producción. Vale la pena para archivos de configuración editados a mano
• Saber dónde aparecen: las comas finales surgen sobre todo en archivos de configuración editados a mano, en JSON pegado desde código .js y en cadenas montadas por concatenación. El JSON generado por un serializador real es seguro

JSON5 y JSONC sí permiten comas finales

Si sigues queriendo una coma final (por ejemplo, para diffs más limpios al añadir una línea), hay formatos que la permiten.

• JSON5 es un superset de JSON con especificación formal que permite comas finales, comentarios, claves sin comillas y comillas simples
• JSONC (JSON with Comments, que usa VS Code) añade comentarios, y sus analizadores pueden aceptar comas finales de forma opcional

El matiz es el alcance: están bien para archivos de configuración que lee una herramienta que los entiende, pero no son válidos para una carga de API, para package.json ni para ningún servicio que use un JSON.parse estricto. La comparación completa, incluido cómo la Sección 9 de RFC 8259 permite estas extensiones, está en ¿Se permiten comentarios en JSON?, que aborda los mismos supersets desde el ángulo de los comentarios.

Si tu objetivo es solo un JSON estricto y legible, pasa el resultado por el formateador de JSON y consulta los consejos para formatear JSON para mantener ordenadas las cargas grandes.

Preguntas frecuentes

¿Se permiten comas finales en JSON?

No. RFC 8259 define las comas como separadores entre valores y no permite ningún elemento tras el último valor, así que una coma antes de un cierre } o ] es inválida. Un analizador estricto la rechaza con un error como Unexpected token }.

¿Cómo encuentro y elimino una coma final?

Pega el JSON en el formateador de JSON. El mensaje de error apunta al corchete de cierre que sigue a la coma sobrante, así que borra la coma de la línea anterior y vuelve a ejecutar. Para evitarla del todo, genera el JSON con JSON.stringify en lugar de montar cadenas a mano.

¿Por qué JavaScript permite comas finales pero JSON no?

Los literales de objeto y array de JavaScript las permiten por comodidad. JSON es un formato de datos estricto que lee JSON.parse, sigue RFC 8259 y no tiene regla para un elemento tras el último valor. El mismo texto es válido como literal de JS e inválido como JSON.

¿Qué mensaje de error causa una coma final?

Lo más habitual es Unexpected token } (o ]) en V8/Node, Expected double-quoted property name en V8 más reciente y Expecting property name enclosed in double quotes en Python. Todos significan que el analizador encontró un corchete de cierre donde esperaba otro valor o clave.

¿Puedo simplemente permitir comas finales en vez de eliminarlas?

Algunos analizadores se pueden configurar para tolerarlas (por ejemplo AllowTrailingCommas de .NET), pero eso solo ayuda al código que lee el archivo: no lo hace válido para otro analizador ni para su transmisión. Para un JSON interoperable, elimina la coma.

¿Funcionan las comas finales en JSON5?

Sí. JSON5 permite comas finales de forma explícita, junto con comentarios y claves sin comillas. Sirve para archivos de configuración locales, pero no para datos de API, que deben ser JSON estricto según RFC 8259.

Resumen

• Una coma final es la coma antes de un cierre } o ]; el JSON estándar la prohíbe
• Los errores se ven como Unexpected token } o Expecting property name enclosed in double quotes; la posición informada es el corchete, así que la coma está justo antes
• La corrección más rápida es pegar el archivo en el formateador de JSON, leer la línea y borrar la coma
• Genera JSON con JSON.stringify y formatea al guardar para evitar que vuelvan las comas finales
• JSON5 y JSONC permiten comas finales, pero solo para herramientas que los entiendan, no para cargas de API