Coma final en JSON (trailing comma): encuentra la línea y borra un carácter

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. En la mayoría de los analizadores, 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 — Python es la excepción, como muestra la tabla siguiente.

Pasar la misma entrada por cinco analizadores muestra cuánto varía en realidad esa posición informada (medido en scripts/benchmarks/json-trailing-comma/, 2026-08-17, Node.js v26.7.0 / Python 3.14.6 / jq 1.7.1-apple / json5 2.2.3 / jsonc-parser 3.3.1). La entrada es este objeto multilínea:

{
  "a": 1,
  "b": 2,
}

La posición informada se divide según el analizador: V8 y jsonc-parser señalan el corchete de cierre (offset 22 / line 4 column 1), jq señala la línea donde está el corchete, y solo Python señala la propia coma (line 3 column 9).

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 8259Se abre en una pestaña nueva, 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.

Eliminar comas finales en Python

El módulo json de la biblioteca estándar rechaza las comas finales, pero el paquete json5 las analiza según la especificación JSON5 (que las permite). Al pasar por un analizador real, no corrompe una secuencia ,} dentro de un valor de cadena como puede hacerlo una expresión regular.

# pip install json5
import json, json5

with open("broken.json") as f:
    data = json5.load(f)

with open("fixed.json", "w") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

Eliminar comas finales en Node.js

Lee el archivo con el paquete json5 de npm y vuelve a escribirlo con el JSON.stringify estándar.

// npm install json5
import JSON5 from "json5";
import fs from "node:fs";

const data = JSON5.parse(fs.readFileSync("broken.json", "utf8"));
fs.writeFileSync("fixed.json", JSON.stringify(data, null, 2));

Corregir muchos archivos a la vez con sed

Para pipelines de CI o scripts de shell que necesitan limpiar muchos archivos, sed es la opción más rápida. Conlleva el mismo riesgo de falsos positivos que la expresión regular anterior, así que valida siempre la salida con un paso de análisis.

sed -E 's/,[[:space:]]*([}\]])/\1/g' broken.json > fixed.json
python3 -c "import json; json.load(open('fixed.json'))"  # validar

Por qué jq no puede arreglarlo

El analizador de jq es estricto: rechaza cualquier entrada que contenga una coma final, por lo que jq . broken.json se detiene con un error en lugar de reparar el archivo. jq es una herramienta para transformar y consultar JSON válido — usa uno de los métodos anteriores para eliminar la coma primero y luego procesa la salida reparada con jq.

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
• 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

De dónde viene realmente trailingComma

El formateo al guardar puede ser la razón de que vuelva una coma final. Esto es lo que dicen la documentación de Prettier y su rastreador de issues sobre cuándo ocurre:

Una puerta de JSON.parse en CI

Un linter que entienda JSON, o un paso de JSON.parse en tu build, detiene la coma final antes de que llegue a producción. Una versión mínima no necesita ninguna dependencia:

node -e "JSON.parse(require('fs').readFileSync(process.argv[1], 'utf8'))" config.json

Ejecútalo como pre-commit hook, o en un bucle sobre cada archivo .json en CI. Vale la pena añadirlo en los archivos de configuración editados a mano, porque son justo donde una coma final tiende a colarse de nuevo.

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 de forma incondicional — es el único de los cinco analizadores medidos con accepted: true y sin ningún error (scripts/benchmarks/json-trailing-comma/).
• JSONC (JSON with Comments, que usa VS Code) añade comentarios. Su implementación jsonc-parser hace recuperación tolerante (lenient recovery): nunca lanza una excepción ante una coma final y sigue devolviendo un valor, pero registra esa coma final como error en su array errors (fila jsonc-parser de la tabla anterior). Devolver un valor y estar formalmente aceptado son cosas distintas — que un archivo de configuración de VS Code "permita" una coma final se refiere a lo primero, no a lo segundo.

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