# ¿Por qué la API devuelve 101, 119, 142 o 209? Todos los códigos de error del backend, reproducidos

Lanzamos 48 solicitudes contra dos backends en producción y capturamos 15 códigos de error numéricos, cada uno con su status HTTP, cuerpo y causa. Un código, el 101, cubre cinco situaciones distintas, y es el único que llega como 404.

URL: https://www.back4app.com/blog/es/por-que-la-api-devuelve-101-119-142-o-209
Publicado: 2026-11-08 · Probado: 2026-09-24
Probado en: Backend: Back4app, plan Free, USA East · Sondas: bash + curl en macOS · Reglas: hooks de Cloud Code desplegados desde el editor de la dashboard
Publisher: Back4app Engineering

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](https://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.

![Arquitectura: una solicitud pasa por cinco etapas dentro del backend y la primera etapa que pone objeciones responde: el gateway de la API comprueba el App ID, la clave, el cuerpo JSON y la ruta (401, 403, 400, 404, sin código); los permisos a nivel de clase responden 101 o 119; los hooks y funciones de Cloud Code lanzan 142, 206, 119, 209 o 141; el schema responde 105, 107, 111; la ACL de la fila oculta filas como 101; la clase de usuarios añade 101, 202, 203, 125, 200, 201, 204, 209](/blog/blog-assets/why-does-the-api-return-101-119-142-or-209/architecture-diagram.svg)

| 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](#por-qué-post-login-devuelve-101-invalid-usernamepassword) |
| 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](#por-qué-una-fila-que-veo-en-la-dashboard-devuelve-101-object-not-found) |
| 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](#por-qué-una-solicitud-anónima-devuelve-101-permission-denied-user-needs-to-be-authenticated) |
| 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](#por-qué-count-devuelve-119-cuando-find-en-la-misma-clase-funciona) |
| 119 | 400 | tu propio mensaje (`moderators only.`) | una Cloud Function lanzó `OPERATION_FORBIDDEN` | [count vs find](#por-qué-count-devuelve-119-cuando-find-en-la-misma-clase-funciona) |
| 142 | 400 | tu propio mensaje (`username needs at least 3 characters.`) | un hook `beforeSave` lanzó `VALIDATION_ERROR` | [registro 142](#por-qué-el-registro-devuelve-142-username-needs-at-least-3-characters) |
| 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](#por-qué-el-registro-devuelve-202-o-203-account-already-exists) |
| 209 | 400 | `Invalid session token` | un token inventado, ningún token, o un token que ya hizo logout | [209 tras el logout](#por-qué-la-api-devuelve-209-invalid-session-token-justo-después-del-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](#por-qué-la-master-key-recibe-206-session-missing-de-un-hook-beforesave) |
| 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](#por-qué-una-cloud-function-devuelve-141-y-qué-trae-el-mensaje) |
| 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](#qué-códigos-menores-capturaron-las-sondas-105-107-111-125-200-201-y-204) |
| 200 / 201 / 204 | 400 | falta el username / la contraseña / el e-mail | el cuerpo de la solicitud | [códigos menores](#qué-códigos-menores-capturaron-las-sondas-105-107-111-125-200-201-y-204) |
| ninguno | 401 | `unauthorized` | sin `X-Parse-Application-Id`, o uno que no nombra ninguna app | [404 vs 403](#por-qué-una-contraseña-incorrecta-es-un-404-pero-una-clave-incorrecta-es-un-403) |
| ninguno | 403 | `unauthorized` | App ID correcto, clave incorrecta o ausente | [404 vs 403](#por-qué-una-contraseña-incorrecta-es-un-404-pero-una-clave-incorrecta-es-un-403) |
| ninguno | 400 | la frase del parser de JSON | el cuerpo no es JSON válido | [404 vs 403](#por-qué-una-contraseña-incorrecta-es-un-404-pero-una-clave-incorrecta-es-un-403) |
| ninguno | 404 | `{"message":"Not Found","error":{}}` | la ruta no existe | [404 vs 403](#por-qué-una-contraseña-incorrecta-es-un-404-pero-una-clave-incorrecta-es-un-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.

```bash
# 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"}'
```

```json
{"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`:

```bash
# 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"
```

```json
{"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](https://www.back4app.com/blog/lock-down-a-backend-your-frontend-talks-to).

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:

```bash
# 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"
```

```json
{"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*.

{/* screenshot: clp-dialog-note-count-empty.jpg — El diálogo Class Level Permission de la clase Note: Public desmarcado, Authenticated marcado en Read y Write, y la vista Advanced en JSON mostrando "count": {} */}

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.

```bash
# 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"
```

```json
{"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:

```javascript
// 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:

```javascript
// 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);
});
```

```bash
# 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":"ab@example.com","password":"Passw0rd!"}'
```

```json
{"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](https://www.back4app.com/blog/add-signup-login-password-reset-without-an-auth-server).

## ¿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:

```bash
# 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":"other@example.com","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":"ana@example.com","password":"Passw0rd!"}'
```

```json
{"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 `Ana@Example.com` y `ana@example.com` 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:

```bash
# 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"
```

```json
{"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`:

```javascript
// 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.");
```

```bash
# 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"}'
```

```json
{"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:

```bash
# 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 '{}'
```

```json
{"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:

```json
{"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.

{/* screenshot: logs-cloud-code-typeerror-141.jpg — La página Logs del backend mostrando el TypeError "Tried to create an ACL with an invalid permission type." lanzado dentro de beforeSave("Note"), con su marca de tiempo */}

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:

```bash
# 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", '
```

```json
{"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.

## ¿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 auth`** con 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 `data` hasta que tres ejecuciones coincidan; la puerta se cierra en todos los servidores al final, no a la vez. El cerrojo de `Note` y los 22 minutos están en [Tu frontend habla directamente con la base de datos. Así proteges el backend](https://www.back4app.com/blog/lock-down-a-backend-your-frontend-talks-to).
- **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](https://www.back4app.com/blog/add-signup-login-password-reset-without-an-auth-server); si tu app todavía no tiene clase de usuarios, ese post es el paso anterior.
