CORS no protege tu API: qué hace y qué sí la protege
Guía/ 14 min de lectura
Una API con CORS restringido sigue respondiendo a curl y a cualquier servidor. Lo probamos en local y armamos lo que sí la protege: autenticación, permisos y límites.
- Node.js
- Seguridad
En este artículo (8)
CORS no protege tu API. Es una regla que aplica el navegador para decidir si el JavaScript de una página de otro origen puede leer la respuesta de tu servidor. curl, un script o cualquier servidor lo ignoran y reciben la respuesta. Lo que protege tu API es la autenticación, la autorización por usuario y el límite de peticiones.
En este artículo lo comprobamos con un servidor de Node en local, desde curl y desde Chromium: qué llega al servidor y qué puede leer la página. Después armamos las tres capas que sí protegen la API, sin dependencias, y una configuración de CORS correcta. Si tu frontend es Next.js, revisa también qué variables NEXT_PUBLIC terminan en el navegador, y si tu API cobra, cómo evitar cobros dobles con una clave de idempotencia.
El mito y la realidad
El mito suena así: «configuré CORS para que solo mi dominio pueda llamar a la API, así que nadie más puede usarla». Es una confusión comprensible. El error de CORS es lo primero que ves cuando tu frontend no logra hablar con tu backend, y parece un muro.
La realidad, según la guía de CORS de MDN: CORS es un mecanismo basado en cabeceras HTTP con el que un servidor le indica al navegador desde qué otros orígenes debe permitir que se carguen sus recursos. Quien obedece es el navegador. Y lo que bloquea, en muchos casos, no es la petición sino la lectura de la respuesta.
| Lo que se suele creer | Lo que pasa en realidad |
|---|---|
| CORS bloquea las peticiones de otros sitios | Muchas peticiones llegan al servidor y se ejecutan; el navegador solo impide que la página lea la respuesta |
| Con CORS, nadie fuera de mi dominio puede llamar a la API | curl, Postman, un script o un servidor llaman a la API sin ninguna restricción de CORS |
| CORS protege los datos de mis clientes | Los protege que la API exija una sesión y compruebe que cada recurso es del usuario que lo pide |
| Si salió un error de CORS, la petición no hizo nada | En nuestra prueba, un POST de formulario bloqueado se ejecutó igual: el servidor guardó el dato |
CORS sí sirve para algo: relaja, de forma controlada, la política del mismo origen del navegador, que impide que otra página lea los datos de tu sitio con la sesión de tu usuario. Es una protección para el usuario dentro de su navegador, no un control de acceso para tu servidor.
Qué hace realmente CORS en el navegador
Dos URLs tienen el mismo origen si coinciden el protocolo, el host y el puerto. https://tienda.example y https://api.tienda.example son orígenes distintos; http://localhost:5173 y http://localhost:5174, también. MDN lo resume así: las escrituras entre orígenes (enlaces, redirecciones, envíos de formularios) suelen estar permitidas, y las lecturas entre orígenes suelen estar prohibidas.
Cuando el JavaScript de una página llama con fetch() a otro origen, el navegador agrega la cabecera Origin y sigue uno de dos caminos:
- Petición simple.
GET,HEADoPOST, sin cabeceras propias fuera de las permitidas y con unContent-Typede formulario (application/x-www-form-urlencoded,multipart/form-dataotext/plain). El navegador la envía directamente. Si la respuesta no trae unAccess-Control-Allow-Originque coincida, la página no puede leerla, pero el servidor ya la recibió y la procesó. - Petición con preflight. Todo lo demás: una cabecera
Authorization, unContent-Type: application/json, unPUTo unDELETE. Antes, el navegador manda unOPTIONSconAccess-Control-Request-MethodyAccess-Control-Request-Headers. Si la respuesta no lo autoriza, la petición real no se envía.
Lo probamos en Chromium 151 con Playwright. La API corre en http://127.0.0.1:8787 y solo permite el origen http://localhost:5173. Lanzamos las mismas tres llamadas desde una página en ese origen y desde otra en http://localhost:5174. La columna del servidor sale de su propio registro:
| Llamada desde localhost:5174 (no permitido) | Qué llegó al servidor | Qué obtuvo la página |
|---|---|---|
POST /api/subscribe con un formulario | El POST; el servidor guardó el correo | TypeError: Failed to fetch |
GET /api/orders/1001 sin token | El GET; respondió 401 | TypeError: Failed to fetch |
GET /api/orders/1001 con Authorization | Solo el OPTIONS; el GET nunca llegó | TypeError: Failed to fetch |
Desde localhost:5173 la página leyó las tres respuestas (201, 401 y 200), y la tercera llegó al servidor como un OPTIONS seguido del GET. El dato que importa es el primero: el correo enviado desde el origen bloqueado quedó guardado. La siguiente suscripción desde el origen permitido devolvió {"subscribed":3}, no 2.
Fíjate también en lo que vio la página: un TypeError sin detalles. MDN lo explica: por seguridad, el JavaScript no recibe los detalles de un fallo de CORS; solo la consola los muestra. En Chromium, la consola decía No 'Access-Control-Allow-Origin' header is present on the requested resource.
Por qué curl o un servidor lo ignoran
CORS existe para proteger al usuario dentro de su navegador: que una página que abrió no lea, con sus cookies, los datos de otro sitio. curl no tiene página, ni usuario, ni sesión ajena que proteger, así que no aplica ninguna regla. Además, puede mandar la cabecera Origin que quiera. Lo mismo vale para un script de Python, Postman o el backend de cualquier otra persona.
Desliza la figura para verla completa
Con la misma API, primero sin cabecera Origin:
$ curl -si http://127.0.0.1:8787/api/orders/1001 -H "Authorization: Bearer tok_ana"
HTTP/1.1 200 OK
Vary: Origin
Content-Type: application/json
{"id":"1001","userId":"ana","total":1250}
Y ahora haciéndonos pasar por un origen que la API no permite:
$ curl -si http://127.0.0.1:8787/api/orders/1001 -H "Authorization: Bearer tok_ana" -H "Origin: https://otra-tienda.example"
HTTP/1.1 200 OK
Vary: Origin
Content-Type: application/json
{"id":"1001","userId":"ana","total":1250}
- La primera línea de cada bloque es el comando:
-squita la barra de progreso e-imuestra las cabeceras de la respuesta. HTTP/1.1 200 OKen los dos casos: el servidor respondió lo mismo.- En el segundo no hay
Access-Control-Allow-Origin, porquehttps://otra-tienda.exampleno está en la lista. A curl le da igual. - La última línea es el pedido completo. Omitimos las cabeceras
Date,Connection,Keep-AliveyTransfer-Encoding, que no cambian nada.
Lo único que protegió ese pedido es que el comando llevaba un token válido. Sin token, la respuesta habría sido un 401. Ahí está la protección real.
Cómo proteger la API: autenticación, autorización por usuario y límites de peticiones
Una API pública en internet recibe peticiones de cualquier cliente. Cada una tiene que pasar tres controles en el servidor: ¿quién eres? (autenticación), ¿puedes tocar esto? (autorización) y ¿cuántas veces lo has intentado? (límite de peticiones). Como corren en el servidor, valen igual para el navegador, para curl y para cualquier otro cliente.
Desliza la figura para verla completa
1. Autenticación
const TOKENS = new Map([
["tok_ana", "ana"],
["tok_beto", "beto"],
]);
function authenticate(req) {
const [scheme, token] = (req.headers.authorization ?? "").split(" ");
return scheme === "Bearer" ? (TOKENS.get(token) ?? null) : null;
}
TOKENSrelaciona cada token con un usuario. En la demo es unMapen memoria; en tu app, aquí verificas la sesión o el token firmado con tu librería de autenticación.authenticatelee la cabeceraAuthorizationy la separa en esquema y token.- Si el esquema es
Bearery el token existe, devuelve el id del usuario; en cualquier otro caso,null.
2. Autorización por usuario
Estar autenticado no basta. El error más caro en la API de una tienda es devolver el pedido 1002 a cualquiera que pida /api/orders/1002 solo porque tiene sesión. Cada recurso se compara con el usuario que lo pide:
if (!userId) return send(res, 401, { error: "unauthenticated" });
const match = req.url.match(/^\/api\/orders\/(\w+)$/);
if (req.method === "GET" && match) {
const order = ORDERS.get(match[1]);
if (!order || order.userId !== userId) return send(res, 404, { error: "not_found" });
return send(res, 200, order);
}
send(res, 404, { error: "not_found" });
- Sin usuario, 401 y nada más.
- La expresión regular saca el id de la URL:
/api/orders/1001da1001. order.userId !== userIdes la autorización: el pedido existe, pero no es tuyo.- Respondemos 404 en los dos casos (no existe o no es tuyo) para no confirmar qué ids existen. Un 403 también es válido; lo importante es no devolver el dato.
Con el token de beto pidiendo el pedido de ana:
$ curl -si http://127.0.0.1:8787/api/orders/1001 -H "Authorization: Bearer tok_beto"
HTTP/1.1 404 Not Found
{"error":"not_found"}
3. Límite de peticiones
const WINDOW_MS = 60_000;
const MAX_REQUESTS = 5;
const hits = new Map();
function rateLimited(key) {
const now = Date.now();
const entry = hits.get(key);
if (!entry || now - entry.start >= WINDOW_MS) {
hits.set(key, { start: now, count: 1 });
return false;
}
entry.count += 1;
return entry.count > MAX_REQUESTS;
}
setInterval(() => {
const now = Date.now();
for (const [key, entry] of hits) if (now - entry.start >= WINDOW_MS) hits.delete(key);
}, WINDOW_MS).unref();
WINDOW_MSyMAX_REQUESTS: 5 peticiones por minuto por cliente (valores ilustrativos; ajústalos a tu tráfico).hitsguarda, por clave, cuándo empezó la ventana y cuántas peticiones lleva.- Si no hay entrada o la ventana ya venció, empieza una nueva con 1.
- Si no, suma 1 y devuelve
truecuando pasa del máximo. - El
setIntervalborra las ventanas vencidas cada minuto para que elMapno crezca sin fin;unref()evita que ese temporizador mantenga vivo el proceso.
Así se usa al principio del manejador:
const userId = authenticate(req);
if (rateLimited(userId ?? req.socket.remoteAddress)) {
res.setHeader("Retry-After", "60");
return send(res, 429, { error: "too_many_requests" });
}
- La clave es el usuario si hay token y, si no, la IP. Así el límite también frena a quien prueba tokens al azar.
- Al pasarse, responde 429 con
Retry-Afteren segundos.
$ for i in 1 2 3 4 5 6; do curl -s -o /dev/null -w "%{http_code} " http://127.0.0.1:8787/api/orders/1002 -H "Authorization: Bearer tok_beto"; done
200 200 200 200 200 429
$ curl -si http://127.0.0.1:8787/api/orders/1002 -H "Authorization: Bearer tok_beto" | head -4
HTTP/1.1 429 Too Many Requests
Vary: Origin
Retry-After: 60
Este límite vive en la memoria de un proceso. Si tu API corre en varias instancias, cada una cuenta por su lado: usa un almacén compartido o el límite de tu proveedor. Y si estás detrás de un proxy, req.socket.remoteAddress es la IP del proxy, no la del cliente.
Cómo configurar CORS correctamente
CORS sigue haciendo falta cuando tu frontend vive en otro origen que tu API, por ejemplo https://tienda.example llamando a https://api.tienda.example. Si los dos comparten origen, como un Next.js que llama a su propio /api, no necesitas ninguna cabecera CORS. Esta es la función de la demo:
const ALLOWED_ORIGINS = new Set((process.env.ALLOWED_ORIGINS ?? "").split(",").filter(Boolean));
function cors(req, res) {
const origin = req.headers.origin;
res.setHeader("Vary", "Origin");
if (!origin || !ALLOWED_ORIGINS.has(origin)) return;
res.setHeader("Access-Control-Allow-Origin", origin);
if (req.method === "OPTIONS") {
res.setHeader("Access-Control-Allow-Methods", "GET, POST");
res.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type");
res.setHeader("Access-Control-Max-Age", "600");
}
}
ALLOWED_ORIGINSes una lista exacta que viene de una variable de entorno, por ejemploALLOWED_ORIGINS=https://tienda.example.Vary: Originva siempre: la respuesta cambia según el origen, y así ninguna caché le sirve a un origen la respuesta de otro.- Si no hay
Origino no está en la lista, no se agrega nada. No es un bloqueo: simplemente no se le da permiso al navegador. - Si está, se devuelve ese origen exacto en
Access-Control-Allow-Origin; nunca*ni lo que llegue sin comprobar. - Solo en el preflight (
OPTIONS) se declaran los métodos, las cabeceras permitidas yAccess-Control-Max-Age: cuántos segundos puede guardar el navegador esa respuesta.
const server = createServer(async (req, res) => {
console.log(`${req.method} ${req.url} origin=${req.headers.origin ?? "-"}`);
cors(req, res);
if (req.method === "OPTIONS") return res.writeHead(204).end();
- La primera línea registra método, ruta y origen: de ahí sale la columna del servidor de la tabla anterior.
cors()corre antes que todo lo demás, así que también los 401, 404 y 429 llevan las cabeceras. Si solo las pones en las respuestas 200, tu frontend ve un error de CORS cuando el servidor en realidad le dijo 401. En nuestra prueba, desde el origen permitido, la página leyó el 401 sin problema.- El
OPTIONSresponde 204 sin cuerpo y sin pasar por la autenticación: según MDN, un preflight nunca lleva credenciales.
Así responde la API a un preflight, visto con curl:
$ curl -si -X OPTIONS http://127.0.0.1:8787/api/orders/1001 -H "Origin: https://tienda.example" -H "Access-Control-Request-Method: GET" -H "Access-Control-Request-Headers: authorization"
HTTP/1.1 204 No Content
Vary: Origin
Access-Control-Allow-Origin: https://tienda.example
Access-Control-Allow-Methods: GET, POST
Access-Control-Allow-Headers: Authorization, Content-Type
Access-Control-Max-Age: 600
Desliza la figura para verla completa
Cookies y credenciales
Si tu frontend se autentica con cookies en lugar de un token en Authorization, el fetch necesita credentials: "include" y la API debe responder Access-Control-Allow-Credentials: true. En ese caso, Access-Control-Allow-Origin tiene que ser un origen concreto: según MDN, con credenciales el comodín * no sirve. Lo probamos con una API que respondía *. Sin credenciales, la página leyó el 200; con credentials: "include", Chromium lo bloqueó con este mensaje:
The value of the 'Access-Control-Allow-Origin' header in the response must not be the wildcard '*' when the request's credentials mode is 'include'.
Errores comunes
- Usar CORS como control de acceso. No frena a curl, a scripts ni a servidores, y con las peticiones simples ni siquiera impide que el servidor las ejecute.
- Reflejar cualquier
Origin. Copiar elOriginde la petición enAccess-Control-Allow-Originsin compararlo con una lista equivale a permitir todos los orígenes. ConAccess-Control-Allow-Credentials: true, cualquier página podría leer datos con la sesión de tu usuario. - Comparar orígenes con
includesostartsWith."https://tienda.example.otro.com".startsWith("https://tienda.example")devuelvetrue. Usa una comparación exacta, como elSetde la demo. - Permitir
null. La referencia de Access-Control-Allow-Origin en MDN advierte que los documentosdata:,file:y en sandbox tienen origennull, y que cualquiera puede crear uno. - Olvidar
Vary: Origin. Con una CDN o una caché delante, la respuesta con el permiso de un origen puede acabar servida a otro. - Poner las cabeceras CORS solo en las respuestas buenas. El frontend ve un error de CORS en lugar del 401 o el 429 real, y depurarlo cuesta el doble.
- Confiar en el preflight para los endpoints que cambian datos. Un
POSTde formulario no tiene preflight. Si cambia algo importante, exige autenticación y, si usas cookies, un token CSRF.
Preguntas frecuentes
¿CORS protege contra CSRF?
No por sí solo. Un formulario de otro sitio puede enviar un POST simple a tu API sin preflight, y en nuestra prueba el servidor lo ejecutó. Para frenar escrituras entre orígenes, MDN recomienda comprobar en la petición un token impredecible: el token CSRF.
¿Por qué funciona en Postman y no en mi frontend?
Porque Postman no es un navegador y no aplica CORS. Si el navegador muestra el error, a la respuesta le falta un Access-Control-Allow-Origin con tu origen, o el preflight no autoriza tu método o tus cabeceras. La consola del navegador te dice cuál de los dos es.
¿Puedo usar Access-Control-Allow-Origin: *?
Sí, para datos públicos que cualquiera puede leer sin sesión, como un catálogo o el stock visible en la tienda. Con cookies o credenciales no funciona, y para datos privados no lo necesitas: usa la lista exacta de orígenes.
¿Cómo se configura CORS en Next.js?
En un route handler, devolviendo las mismas cabeceras en el Response. La documentación de route.js trae un ejemplo con * y, para varios handlers, propone definirlas en next.config.js. Si la página y la API comparten origen, no hace falta CORS. Y la API necesita igual sus tres capas.
Checklist
- Cada endpoint privado exige autenticación en el servidor.
- Cada recurso se compara con el usuario que lo pide.
- Hay un límite de peticiones por usuario y por IP que responde 429.
- Los endpoints que cambian datos no dependen de CORS ni del preflight.
Access-Control-Allow-Originsale de una lista exacta de orígenes.Vary: Originva en todas las respuestas.- Con cookies: un origen concreto y
Access-Control-Allow-Credentials: true, nunca*. - Probaste la API con curl, sin
Originy con uno falso, y no entrega nada sin token.
CORS decide quién puede leer una respuesta dentro del navegador; la seguridad de tu API se decide en el servidor. Si trabajas con Next.js, sigue con las variables NEXT_PUBLIC y los secretos, porque una clave que llega al bundle tampoco la protege CORS. Si tu API procesa pagos, revisa cómo evitar cobros dobles con idempotencia, y si descuenta inventario, cómo evitar la sobreventa.
¿Viste esto en Instagram? Comenta CORS en el Reel y te mando la guía.
Escrito por

Publicado el 30 de octubre de 2026 · actualizado el 1 de noviembre de 2026