Tu formulario de inicio de sesión acaba de mostrar 101 Invalid username/password a alguien que escribió la contraseña correcta. O la app recibió un 209 segundos después de iniciar sesión, o un 119 en una query que ayer funcionaba, o un 142 con una frase que nadie de tu equipo escribió.
El número es todo el diagnóstico que tienes, y la documentación le dedica una sola línea a cada uno.
Un código de error del backend es el campo numérico code del cuerpo JSON de una solicitud fallida, separado del status HTTP; un mismo código puede tener varias causas, y el mensaje error que lo acompaña es lo que las distingue. Esa frase es el post. El resto es la prueba, código a código.
Escribimos un script que provoca cada código a propósito y lo ejecutamos tres veces contra dos backends en producción el 24 de septiembre de 2026: 48 solicitudes, 43 respuestas de error, 15 códigos numéricos. Cada status y cada cuerpo de abajo están pegados de esas ejecuciones, y las ejecuciones están en el repositorio.
Consigue el código funcionando: el repositorio companion está en github.com/templates-back4app/backend-error-codes. reproduce.sh imprime una fila por solicitud (código esperado, status HTTP, código, mensaje) y seed.sh prepara las clases y los usuarios.
cloud/main.js es el Cloud Code detrás de los errores de hook, y results/ guarda las ejecuciones que cita este post.
¿Qué código significa qué, y dónde se produce cada uno?
La tabla de abajo es la respuesta al título. El código es el campo code del cuerpo; el status HTTP es lo que imprimió curl -w '%{http_code}'; la causa es lo que hicimos para obtenerlo.
La primera etapa del backend que pone objeciones es la que responde, y nada de lo que viene después se ejecuta, así que el orden de las secciones es el orden en que una solicitud se las encuentra.
| Código | HTTP | Significado | Causa más probable | Sección |
|---|---|---|---|---|
| 101 | 404 | Invalid username/password. | contraseña incorrecta, o un username que no existe | POST /login |
| 101 | 404 | Object not found. | un id que no existe, o una fila que la ACL de quien llama no deja ver | una fila que ves |
| 101 | 404 | Permission denied, user needs to be authenticated. | el permiso a nivel de clase exige sesión y no se envió ninguna | solicitud anónima |
| 119 | 400 | Permission denied for action count on class Note. | el permiso a nivel de clase no permite a nadie para esa operación; count es una entrada propia | count vs find |
| 119 | 400 | tu propio mensaje (moderators only.) | una Cloud Function lanzó OPERATION_FORBIDDEN | count vs find |
| 142 | 400 | tu propio mensaje (username needs at least 3 characters.) | un hook beforeSave lanzó VALIDATION_ERROR | registro 142 |
| 202 / 203 | 400 | Account already exists for this username. / …email address. | registro con un username o un e-mail ya en uso | registro 202 / 203 |
| 209 | 400 | Invalid session token | un token inventado, ningún token, o un token que ya hizo logout | 209 tras el logout |
| 206 | 400 | tu propio mensaje (log in to create a note.) | un hook necesitaba request.user y la solicitud no tenía sesión (master key incluida) | master key 206 |
| 141 | 400 | Invalid function: "doesNotExist", o el mensaje de la excepción | función sin desplegar, o un error que no es de Parse lanzado en Cloud Code | 141 |
| 105 / 107 / 111 / 125 | 400 | nombre de campo inválido / nombre de clase inválido / tipo incorrecto / e-mail inválido | el cuerpo de la solicitud | códigos menores |
| 200 / 201 / 204 | 400 | falta el username / la contraseña / el e-mail | el cuerpo de la solicitud | códigos menores |
| ninguno | 401 | unauthorized | sin X-Parse-Application-Id, o uno que no nombra ninguna app | 404 vs 403 |
| ninguno | 403 | unauthorized | App ID correcto, clave incorrecta o ausente | 404 vs 403 |
| ninguno | 400 | la frase del parser de JSON | el cuerpo no es JSON válido | 404 vs 403 |
| ninguno | 404 | {"message":"Not Found","error":{}} | la ruta no existe | 404 vs 403 |
Cómo lo medimos: reproduce.sh, 29 solicitudes contra el backend user-auth-starter y 19 contra lockdown-lab, los dos en el plan Free en USA East, cada grupo ejecutado tres veces entre las 13:13 y las 13:29 UTC del 24 de septiembre de 2026.
El status es lo que imprimió curl -w '%{http_code}'; code y error se leen del cuerpo con python3. Las filas fueron idénticas en las tres ejecuciones, con la JavaScript key y de nuevo con la Client key.
¿Por qué POST /login devuelve 101 Invalid username/password?
Porque la contraseña está mal, o el username no existe, y el backend se niega a decirte cuál de los dos. Es deliberado: un formulario de inicio de sesión que dice ese usuario no existe le entrega a un atacante una lista de cuentas. Los dos casos respondieron HTTP 404 con el mismo cuerpo, tres ejecuciones de tres.
# Stack: bash + curl | File: reproduce.sh (rows 8 and 9)
curl -s -w '\nHTTP %{http_code}\n' -X POST "$BASE/login" \
-H "X-Parse-Application-Id: $APP_ID" -H "X-Parse-REST-API-Key: $REST_KEY" \
-H "Content-Type: application/json" -d '{"username":"ana","password":"wrong"}'
{"code":101,"error":"Invalid username/password."}
HTTP 404
La solución está en tu lado del formulario: un solo mensaje genérico (usuario o contraseña incorrectos), un enlace al flujo de restablecimiento y ningún bucle de reintentos.
Si un usuario insiste en que la contraseña es correcta, revisa si el username lleva un espacio al final y si la cuenta se creó con un username distinto del que escribe; el e-mail no se acepta en lugar del username salvo que lo envíes en el campo email.
Una forma más de llegar a esta fila: GET /login?username=ana&password=wrong responde el mismo 404 / 101 (fila 29). El endpoint acepta una query string, así que una contraseña en una URL acaba en un log. Envíala en el cuerpo.
¿Por qué una fila que veo en la dashboard devuelve 101 Object not found?
Porque la ACL de esa fila no te incluye. Una fila que quien llama no puede leer y una fila que no existe reciben el mismo status, el mismo código y el mismo mensaje, a propósito, para que no se pueda sondear si un id existe. Medimos los dos casos, como ana con un id inventado y como bob con una nota que pertenece a ana:
# Stack: bash + curl | File: reproduce.sh (data rows 4, 8 and 9)
curl -s -w '\nHTTP %{http_code}\n' "$BASE/classes/Note/xxxxxxxxxx" \
-H "X-Parse-Application-Id: $APP_ID" -H "X-Parse-REST-API-Key: $REST_KEY" \
-H "X-Parse-Session-Token: $ANA_TOKEN"
curl -s -w '\nHTTP %{http_code}\n' "$BASE/classes/Note/$ANA_NOTE_ID" \
-H "X-Parse-Application-Id: $APP_ID" -H "X-Parse-REST-API-Key: $REST_KEY" \
-H "X-Parse-Session-Token: $BOB_TOKEN"
{"code":101,"error":"Object not found."}
HTTP 404
El mismo cuerpo volvió para el PUT de bob sobre esa nota, y para la master key pidiendo un id que no existe (GET /classes/_User/xxxxxxxxxx).
La clase Note de esta prueba recibe su ACL de un hook beforeSave que concede lectura y escritura solo a quien la crea, que es la configuración de Tu frontend habla directamente con la base de datos. Así proteges el backend.
La solución depende del caso en el que estés. Si el id es real, abre la fila en la dashboard y lee su columna ACL: si nombra un solo id de usuario o está vacía, quien llama no está en la lista.
Lo correcto entonces es una Cloud Function que haga la lectura con la master key para quienes sí deben verla. Si la ACL es pública y sigues recibiendo 101, el id está mal; los ids distinguen mayúsculas y minúsculas.
¿Por qué una solicitud anónima devuelve 101 Permission denied, user needs to be authenticated?
Porque el permiso a nivel de clase para esa operación es Authenticated y la solicitud no llevaba session token. Es la tercera y última cara del 101, y la única cuyo mensaje dice qué hacer. Todas las solicitudes anónimas a Note (find, create y get por id) lo recibieron, tres ejecuciones de tres:
# Stack: bash + curl | File: reproduce.sh (data rows 1 to 3)
curl -s -w '\nHTTP %{http_code}\n' "$BASE/classes/Note" \
-H "X-Parse-Application-Id: $APP_ID" -H "X-Parse-REST-API-Key: $REST_KEY"
{"code":101,"error":"Permission denied, user needs to be authenticated."}
HTTP 404
Fíjate en el orden: un GET /classes/Note/xxxxxxxxxx anónimo recibe este mensaje, no Object not found. El permiso de la clase se comprueba antes de buscar la fila.
La solución es una sesión: inicia la sesión del usuario y envía X-Parse-Session-Token o, si la operación de verdad debe ser pública, cambia el permiso a nivel de clase en Database → la clase → Security → Class Level Permission.
Los dos ajustes tardan en llegar a todos los servidores: después de un cambio de permisos hemos visto solicitudes anónimas respondidas de forma inconsistente durante 22 minutos, así que sondea hasta obtener la misma respuesta varias veces seguidas.
¿Por qué count devuelve 119 cuando find en la misma clase funciona?
Porque count es una entrada propia en los permisos a nivel de clase, y la entrada estaba vacía. ana, con sesión iniciada, recibió 200 en GET /classes/Note y 400 / 119 en GET /classes/Note?count=1 en la misma ejecución. Nadie había bloqueado count a propósito.
Los permisos se habían escrito por la schema API sin una clave count, y el backend lo guardó como count: {}, que no permite a nadie.
# Stack: bash + curl | File: reproduce.sh (data rows 5 and 6)
curl -s -w '\nHTTP %{http_code}\n' "$BASE/classes/Note?count=1&limit=0" \
-H "X-Parse-Application-Id: $APP_ID" -H "X-Parse-REST-API-Key: $REST_KEY" \
-H "X-Parse-Session-Token: $ANA_TOKEN"
{"code":119,"error":"Permission denied for action count on class Note."}
HTTP 400
Esa es la forma general del 119: la operación está denegada por configuración, seas quien seas. Lo reprodujimos de dos maneras más.
Una clase Vault creada con todos los permisos en {} respondió 119 en find y en create, tanto para ana como para un llamante anónimo (Permission denied for action find on class Vault.). Y una Cloud Function que comprueba un role lo lanzó a propósito:
// Stack: Node.js 22.x | Parse Server 7.x | File: cloud/main.js (moderatorList)
const isMod = await new Parse.Query(Parse.Role).equalTo("name", "moderator").equalTo("users", request.user).first({ useMasterKey: true });
if (!isMod) throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, "moderators only.");
ana llamando a moderatorList recibió 400 / 119 moderators only.; bob, que está en el role, recibió la lista. La solución para un 119 nunca es reintentar.
O el permiso es correcto y el cliente no debería estar haciendo esa llamada, o está mal y la solución está en el diálogo Class Level Permission de la dashboard (o en un PUT /schemas/Note con la master key, esta vez con una entrada count).
¿Por qué el registro devuelve 142 username needs at least 3 characters?
Porque un hook beforeSave en la clase _User lanzó Parse.Error.VALIDATION_ERROR con esa frase, y el backend reenvía el mensaje del hook sin cambios. 142 siempre significa tu propio Cloud Code dijo que no; el texto es lo que escribió la persona que programó el hook. En el backend user-auth-starter el hook tiene 17 líneas:
// Stack: Node.js 22.x | Parse Server 7.x | File: cloud/main.js (beforeSave on _User)
Parse.Cloud.beforeSave(Parse.User, (request) => {
const user = request.object;
const email = (user.get("email") ?? "").trim().toLowerCase();
if (!email) throw new Parse.Error(Parse.Error.VALIDATION_ERROR, "an e-mail address is required.");
user.set("email", email);
const username = (user.get("username") ?? "").trim();
if (username.length < 3) throw new Parse.Error(Parse.Error.VALIDATION_ERROR, "username needs at least 3 characters.");
user.set("username", username);
});
# Stack: bash + curl | File: reproduce.sh (row 13)
curl -s -w '\nHTTP %{http_code}\n' -X POST "$BASE/users" \
-H "X-Parse-Application-Id: $APP_ID" -H "X-Parse-REST-API-Key: $REST_KEY" \
-H "Content-Type: application/json" -d '{"username":"ab","email":"[email protected]","password":"Passw0rd!"}'
{"code":142,"error":"username needs at least 3 characters."}
HTTP 400
La solución está en la solicitud, y el mensaje es seguro de mostrar al usuario porque lo escribiste tú. El caso a vigilar es un 142 con una frase que no reconoces: busca VALIDATION_ERROR en tu Cloud Code y, si no está, mira el beforeSave de cada clase que la solicitud toca, incluidas las que arrastra un pointer.
Si un registro como ab responde 201, el hook no está activo. En un backend recién creado, el primer Deploy del editor de Cloud Code no envía nada; despliega otra vez y vuelve a probar. Los detalles están en Cómo añadir autenticación a una app web o Flutter sin escribir un servidor de auth.
¿Por qué el registro devuelve 202 o 203 Account already exists?
Porque el username (202) o el e-mail (203) ya están en otra cuenta, y los dos son únicos en toda la clase _User. Se comprueban en ese orden: una solicitud que repite el username y el e-mail recibe 202. Creamos un usuario de prueba y después intentamos crearlo dos veces más:
# Stack: bash + curl | File: reproduce.sh (rows 11 and 12)
curl -s -w '\nHTTP %{http_code}\n' -X POST "$BASE/users" \
-H "X-Parse-Application-Id: $APP_ID" -H "X-Parse-REST-API-Key: $REST_KEY" \
-H "Content-Type: application/json" -d '{"username":"ana","email":"[email protected]","password":"Passw0rd!"}'
curl -s -w '\nHTTP %{http_code}\n' -X POST "$BASE/users" \
-H "X-Parse-Application-Id: $APP_ID" -H "X-Parse-REST-API-Key: $REST_KEY" \
-H "Content-Type: application/json" -d '{"username":"other","email":"[email protected]","password":"Passw0rd!"}'
{"code":202,"error":"Account already exists for this username."}
HTTP 400
{"code":203,"error":"Account already exists for this email address."}
HTTP 400
La solución es un formulario que reaccione: con 202, ofrece el formulario de inicio de sesión con el username ya rellenado; con 203, ofrece el restablecimiento de contraseña, porque esa persona probablemente tiene una cuenta con otro username. Los dos mensajes son seguros de mostrar.
Ten en cuenta que el hook de arriba pasa el e-mail a minúsculas antes de la comprobación, así que [email protected] y [email protected] chocan como 203; sin ese hook serían dos cuentas.
¿Por qué la API devuelve 209 Invalid session token justo después del logout?
Porque POST /logout borró esa sesión en el servidor y el cliente se quedó con el token. Creamos una cuenta (token A), cerramos sesión con A y pedimos GET /users/me con A: 400 / 209. El mismo status, código y mensaje volvieron para un token inventado y para ningún token en absoluto:
# Stack: bash + curl | File: reproduce.sh (rows 20, 21 and 24)
curl -s -w '\nHTTP %{http_code}\n' "$BASE/users/me" \
-H "X-Parse-Application-Id: $APP_ID" -H "X-Parse-REST-API-Key: $REST_KEY" \
-H "X-Parse-Session-Token: r:0000000000000000000000000000000f"
{"code":209,"error":"Invalid session token"}
HTTP 400
Una Cloud Function puede lanzar el mismo código a propósito: whoami en el backend user-auth-starter y moderatorList en lockdown-lab responden 400 / 209 log in first. cuando request.user está vacío.
El mensaje cambia, el código no, así que el handler del cliente es una sola rama: borrar el token guardado, mostrar el formulario de inicio de sesión y no reintentar. Un token revocado sigue revocado.
El logout revoca un token, no al usuario. Si la misma persona tiene sesión en un teléfono y en una laptop, el token de la laptop sigue funcionando después de que el teléfono cierre sesión; eso se midió en el post de autenticación y se mantiene. Si «cerrar sesión en todas partes» es una funcionalidad, es una Cloud Function que borra las filas _Session del usuario con la master key.
¿Por qué la master key recibe 206 Session missing de un hook beforeSave?
Porque la master key se salta los permisos a nivel de clase y las ACL, no el Cloud Code. El hook de Note en lockdown-lab necesita un usuario al que marcar como propietario; un create con la master key y sin session token llegó a él con request.user sin definir, y el hook lanzó SESSION_MISSING:
// Stack: Node.js 22.x | Parse Server 7.x | File: cloud/main.js (beforeSave on Note)
const owner = request.user ?? note.get("owner");
if (!owner) throw new Parse.Error(Parse.Error.SESSION_MISSING, "log in to create a note.");
# Stack: bash + curl (master key: server side only) | File: reproduce.sh (data row 17)
curl -s -w '\nHTTP %{http_code}\n' -X POST "$BASE/classes/Note" \
-H "X-Parse-Application-Id: $APP_ID" -H "X-Parse-Master-Key: $MASTER_KEY" \
-H "Content-Type: application/json" -d '{"text":"no owner"}'
{"code":206,"error":"log in to create a note."}
HTTP 400
Un cliente anónimo nunca ve esta fila: el permiso de clase lo rechaza con 101 antes de que el hook se ejecute. Así que un 206 en tus logs es casi siempre un job del lado del servidor, un script de migración o una importación desde la dashboard que escribe con la master key y olvida que el hook espera un usuario.
La solución es pasar el propietario de forma explícita (el hook recurre a note.get("owner")), o dejar que el hook se salte su comprobación cuando request.master es true, si eso es lo que quieres.
¿Por qué una Cloud Function devuelve 141, y qué trae el mensaje?
Porque 141 es el código de Cloud Code no produjo un resultado, y hay dos razones muy distintas. La primera es un nombre de función que no está desplegado; el mensaje lo nombra.
La segunda es cualquier error lanzado dentro de un hook o una función que no sea un Parse.Error; el backend lo envuelve en un 141 y deja pasar el mensaje de la propia excepción. Nos encontramos con los dos:
# Stack: bash + curl | File: reproduce.sh (row 25; data row 18 uses the master key)
curl -s -w '\nHTTP %{http_code}\n' -X POST "$BASE/functions/doesNotExist" \
-H "X-Parse-Application-Id: $APP_ID" -H "X-Parse-REST-API-Key: $REST_KEY" \
-H "Content-Type: application/json" -d '{}'
{"code":141,"error":"Invalid function: \"doesNotExist\""}
HTTP 400
Para la segunda razón le enviamos al hook de Note un owner que es un objeto plano en lugar de un pointer a usuario, con la master key. new Parse.ACL({"foo":"bar"}) lanza un TypeError, y esto es lo que vio el cliente:
{"code":141,"error":"Tried to create an ACL with an invalid permission type."}
HTTP 400
El mensaje es el texto de la excepción de JavaScript, no Script failed. Eso es útil para ti y peligroso para tus usuarios: el mensaje de un TypeError puede filtrar nombres de variables y la forma de los objetos.
La solución para el primer caso es un deploy (y un segundo en un backend recién creado). La del segundo es un try/catch en el hook que relance un Parse.Error con un mensaje elegido por ti, y una mirada a la página Logs, donde está el stack trace.
No pudimos hacer que un hook lanzara un Error plano en estos backends sin desplegar Cloud Code nuevo, que requiere la dashboard, así que el TypeError de arriba es el único 141 desde código que medimos; el envoltorio es el mismo para cualquier error que no sea de Parse.
¿Por qué una contraseña incorrecta es un 404 pero una clave incorrecta es un 403?
Porque el status HTTP lo deciden dos capas distintas. Todos los códigos numéricos que reprodujimos llegaron como HTTP 400, salvo el 101, que llega como 404 porque el backend traduce object not found a Not Found y el error de login reutiliza ese código. Antes de todo eso, un gateway comprueba los headers y el cuerpo, y sus cuatro respuestas no traen código alguno:
# Stack: bash + curl | File: reproduce.sh (rows 1 to 6)
curl -s -w '\nHTTP %{http_code}\n' "$BASE/classes/_User" # no App ID
curl -s -w '\nHTTP %{http_code}\n' "$BASE/classes/_User" -H "X-Parse-Application-Id: $APP_ID" # no key
curl -s -w '\nHTTP %{http_code}\n' -X POST "$BASE/login" -H "X-Parse-Application-Id: $APP_ID" \
-H "X-Parse-REST-API-Key: $REST_KEY" -H "Content-Type: application/json" -d '{"username": "ana", '
{"error":"unauthorized"}
HTTP 401
{"error":"unauthorized"}
HTTP 403
{"error":"Expected double-quoted property name in JSON at position 20"}
HTTP 400
| Qué enviaste | HTTP | Cuerpo |
|---|---|---|
sin X-Parse-Application-Id, o un App ID que no nombra ninguna app | 401 | {"error":"unauthorized"} |
| App ID correcto, clave incorrecta o sin clave | 403 | {"error":"unauthorized"} |
| un cuerpo que no es JSON válido | 400 | {"error":"Expected double-quoted property name in JSON at position 20"} |
una ruta que no existe (GET /nothing-here) | 404 | {"message":"Not Found","error":{}} |
| contraseña incorrecta, fila inexistente, fila oculta, sin sesión (101) | 404 | {"code":101,"error":"…"} |
| cualquier otro código numérico (119, 141, 142, 202, 203, 206, 209, …) | 400 | {"code":N,"error":"…"} |
Así que el orden del diagnóstico es: sin code en el cuerpo, la solicitud nunca llegó a las reglas de tu app, y 401 frente a 403 te dice qué header está mal; un 404 con código 101 es una de tres situaciones que el mensaje separa; cualquier otra cosa es un 400 cuyo código es toda la historia.
La tabla oficial de errores lista 107 para un JSON malformado; el backend en producción respondió sin código.
Decide primero por la presencia de code y después por su valor. El status HTTP solo te dice qué capa respondió.
¿Qué códigos menores capturaron las sondas: 105, 107, 111, 125, 200, 201 y 204?
Siete más, todos HTTP 400, todos sobre el cuerpo de la solicitud, y uno de ellos con un efecto secundario. Cada fila de abajo es tres ejecuciones de tres:
| Código | Qué enviamos | error |
|---|---|---|
| 105 | POST /classes/ErrProbe con el campo "bad key" | Invalid field name: bad key. |
| 107 | POST /classes/bad-name (un guion en el nombre de la clase) | schema class name does not revalidate |
| 111 | POST /classes/Note con "text": 123 en una columna String | schema mismatch for Note.text; expected String but got Number |
| 125 | POST /users con "email": "not-an-email" | Email address format is invalid. |
| 200 | POST /users sin username | bad or missing username |
| 200 | POST /login con el cuerpo vacío | username/email is required. |
| 201 | POST /users sin password | password is required |
| 204 | POST /requestPasswordReset sin email | you must provide an email |
El efecto secundario está en el 105. El create fue rechazado, y la clase ErrProbe apareció en el schema de todos modos, vacía y con los permisos por defecto. La borramos, enviamos la solicitud otra vez y volvió a aparecer.
Si tu schema tiene clases que no recuerdas haber creado, puede que las haya creado una escritura rechazada desde un cliente; reproduce.sh borra la suya con DELETE /schemas/ErrProbe después de cada ejecución.
El 107 es la otra sorpresa: la documentación lista 103 para un nombre de clase inválido, y el backend en producción respondió 107 en el POST y, en GET /classes/bad-name, un 200 sin más con {"results":[]}. Un nombre de clase mal escrito en una lectura no falla; no devuelve nada.
¿Qué códigos no pudimos reproducir?
Dos, y no están en la tabla porque no los vimos. 103 (nombre de clase inválido): un GET sobre bad-name respondió 200 con un resultado vacío y un POST respondió 107, tres ejecuciones de tres.
205 (ningún usuario con ese e-mail): POST /requestPasswordReset con una dirección que nadie tiene respondió 200 {}, que es el comportamiento correcto para un formulario de restablecimiento y significa que tu cliente nunca verá un 205 de ese endpoint.
Tampoco intentamos provocar el código 1 (error interno del servidor) ni los códigos de rate limiting y de timeout; necesitan condiciones que un script de sondeo no debería crear en un backend compartido.
¿Qué falla cuando ejecutas reproduce.sh contra tu propio backend?
users ana/bob missing: run ./seed.sh first el grupo data inicia sesión como ana y bob y se detiene si cualquiera de los dos logins falla. Ejecuta ./seed.sh con el mismo .env; crea los dos usuarios, el role moderator y las clases Note y Vault, y es seguro volver a ejecutarlo. Si cambiaste las contraseñas, exporta ANA_PASS y BOB_PASS.
401 unauthorized en todas las filas el APP_ID del .env está mal o tiene un carácter de más al final. Cópialo de nuevo desde App Settings → Security & Keys. La fila 2 del script envía un App ID incorrecto a propósito; si las filas 3 a 29 se parecen a la fila 2, el problema es tu .env.
403 unauthorized en todas las filas el App ID es correcto y JS_KEY no. La misma página, la entrada JavaScript key. Cualquier clave de cliente sirve (KEY_HEADER=X-Parse-Client-Key KEY_VALUE=… ./reproduce.sh dio las mismas filas); la master key se usa solo donde la etiqueta lo dice.
La fila 142 responde 201 el hook de _User no está activo. En un backend recién creado, el primer Deploy del editor de Cloud Code no envía nada: edita main.js, despliega otra vez y vuelve a ejecutar. El registro creó un usuario ab; bórralo en Database → _User o con la master key.
141 Invalid function: "whoami" en la fila 22, misma causa: cloud/main.js no está desplegado, o se desplegó una sola vez. Las dos funciones y los dos hooks viven en ese único archivo.
La fila 206 responde 201 el hook de Note no está activo, así que el create con la master key tuvo éxito y dejó una nota sin propietario y con ACL pública. Despliega y después borra la fila (migrate-acl.sh, en el repositorio lockdown-lab, elimina las notas sin propietario).
Las filas 101 responden 200 en el grupo data el permiso a nivel de clase de Note todavía no ha llegado a todos los servidores. Hemos medido hasta 22 minutos para que un cambio de permisos se asiente; vuelve a ejecutar hasta que tres ejecuciones coincidan, y despliega Cloud Code una vez si se atasca.
python3: command not found el script lee los cuerpos JSON con Python 3. Instálalo, o sustituye las dos llamadas a python3 por jq -r.
¿Cuándo es un error decidir según el código numérico?
Cuando quien llama no es tu propio cliente. Si pones una API propia delante del backend (un servicio Express o FastAPI en un container, por ejemplo), sus consumidores nunca deberían ver un 101 ni un 209.
Tradúcelos en la frontera: el 101 del login se convierte en tu 401, el 209 en tu 401 con una pista de vuelve a autenticarte, el 119 en 403, el 142 en 422 con el mensaje, y todo lo demás en 500 con el código solo en tus logs.
Cuando el mensaje no lo escribiste tú. Las frases detrás del 142, del 206, del 119 desde una función y del 141 desde un throw son tuyas y pueden ir en pantalla. schema mismatch for Note.text; expected String but got Number y Tried to create an ACL with an invalid permission type. son para desarrolladores; muestra un mensaje genérico y registra el original.
Cuando el código oculta la intención a propósito. El 101 no te dirá si una fila existe, y el login no te dirá si el username existe. Un cliente que intenta deducir cualquiera de las dos cosas por el tiempo de respuesta o por la redacción del mensaje está adivinando, y un cambio en el backend romperá la adivinanza.
Si el producto necesita esa distinción, ponla en una Cloud Function para quienes pueden saberla.
Y cuando el status HTTP es la única señal. 401, 403, un JSON malformado y las rutas desconocidas no traen código; un handler que empieza por body.code se rompe con ellos. Comprueba primero el status, después la presencia de code y después su valor.
¿Qué deberías ejecutar contra tu propio backend a continuación?
./reproduce.sh authcon tu propio.env. Compara las 29 filas con la tabla de este post; una fila que difiere es o un hook que tienes (bien) o uno que creías tener (todavía sin desplegar).- Añade una fila por cada hook que escribas. Cada
throw new Parse.Error(...)de tu Cloud Code merece una línea en el script, para que el mensaje que verán tus usuarios sea uno que hayas leído. - Un solo handler para el 209. Borra el token, muestra el formulario de inicio de sesión, nunca reintentes. Es el código que más verás en producción y el que tiene la solución más simple.
- Cierra, después sondea. Si cambias un permiso a nivel de clase, ejecuta el grupo
datahasta que tres ejecuciones coincidan; la puerta se cierra en todos los servidores al final, no a la vez. El cerrojo deNotey los 22 minutos están en Tu frontend habla directamente con la base de datos. Así proteges el backend. - Primero las cuentas. Las filas 101, 202, 203 y 209 salen de las seis llamadas REST de Cómo añadir autenticación a una app web o Flutter sin escribir un servidor de auth; si tu app todavía no tiene clase de usuarios, ese post es el paso anterior.