Volver al blog
Desarrollo Web31 de marzo de 2026

Cómo construir una API REST segura con Next.js 15 y Prisma

Cómo construir una API REST segura con Next.js 15 y Prisma: route handlers del App Router, validación de entrada, autenticación con JWT y el patrón de cliente Prisma que evita agotar la base en desarrollo.

8 min lectura304 vistas
Primer plano de un editor de código en tema oscuro mostrando un componente Svelte con sus importaciones y su marcado

La construcción de APIs REST se ha convertido en una tarea esencial para muchos desarrolladores. Con la creciente demanda de aplicaciones web y móviles que requieren interacción con bases de datos y otros servicios, es fundamental crear APIs que no solo sean funcionales, sino también seguras. En este contexto, Next.js 15 y Prisma emergen como herramientas poderosas para construir APIs robustas y eficientes.

En este artículo, exploraremos cómo puedes aprovechar Next.js 15 y Prisma para desarrollar una API REST segura. Veremos desde los desafíos que enfrentan los desarrolladores al crear APIs, hasta las mejores prácticas y una implementación práctica que te permitirá iniciar tu propio proyecto.

Dónde se rompen las APIs en la práctica

En la era de la digitalización, las APIs desempeñan un papel crucial en la interconexión de servicios y aplicaciones. Sin embargo, muchas veces los desarrolladores se enfrentan a problemas de seguridad y escalabilidad. Las brechas de seguridad pueden resultar en pérdida de datos, robos de información y daños a la reputación de una empresa.

Y conviene decirlo sin cifras infladas: no hace falta un porcentaje para justificar asegurar una API. Los dos huecos que aparecen una y otra vez son concretos y aburridos — endpoints sin autorización por recurso, y entrada que nadie validó.

Autenticación y autorización

Una de las principales preocupaciones al desarrollar una API REST es la autenticación y autorización. Sin estas medidas, cualquier persona podría acceder a los datos sensibles de tu aplicación. La autenticación asegura que solo los usuarios válidos puedan acceder a tu API, mientras que la autorización determina qué datos pueden ver y qué acciones pueden realizar esos usuarios.

La trampa más común es implementar la primera y olvidar la segunda: verificar que el token es válido, y luego devolver el recurso sin comprobar que ese usuario tiene derecho a ese recurso. Un endpoint como /api/pedidos/123 que solo valida la firma deja que cualquier usuario autenticado lea los pedidos de todos.

Validación de datos

Otra cuestión importante es la validación de datos. Cuando se reciben solicitudes en tu API, es fundamental asegurarse de que los datos sean correctos y estén en el formato esperado. La validación inadecuada puede abrir la puerta a ataques como inyección SQL o cross-site scripting (XSS), comprometiendo la seguridad de tu aplicación.

Una nota a favor de Prisma: sus consultas son parametrizadas, así que la inyección SQL clásica no es tu problema mientras uses su API y no $queryRawUnsafe. Lo que sí sigue siendo tu problema es todo lo demás que puede traer un cuerpo de petición malformado.

Mejores prácticas

Para abordar estos problemas, existen una serie de mejores prácticas que se pueden implementar al construir una API REST.

  • Usar HTTPS: Asegúrate de que todas las comunicaciones se realicen a través de HTTPS para cifrar los datos en tránsito.

  • Implementar autenticación robusta: Utiliza métodos como OAuth 2.0 o JWT (JSON Web Tokens) para gestionar la autenticación de usuarios.

  • Validar y sanitizar datos: Siempre valida y sanitiza los datos que recibes para proteger tu API de inyecciones y otros ataques.

  • Limitar la tasa de solicitudes: Implementa límites en la cantidad de solicitudes que un usuario puede realizar en un periodo de tiempo determinado para evitar abusos.

  • Registrar y monitorear: Mantén registros de las actividades en tu API para detectar patrones inusuales que puedan indicar un intento de ataque.

  • Nunca devuelvas el hash: Selecciona explícitamente los campos que sales. Un findUnique sin select te devuelve la contraseña hasheada, y de ahí al JSON de respuesta hay un paso.

¿Necesitas una API que aguante producción?

La construimos con autenticación, autorización por recurso y validación desde el primer endpoint, no después del primer incidente.

Cotizar proyecto

Implementación con App Router

Ahora que hemos discutido las mejores prácticas, es hora de implementar una API REST segura utilizando Next.js 15 y Prisma. Supongamos que estamos construyendo una API para gestionar un sistema de usuarios.

Una aclaración de entrada, porque muchos tutoriales siguen mostrando lo contrario: en Next.js 15 los endpoints se escriben como route handlers del App Router, en app/api/.../route.ts, no como archivos en pages/api.

  1. Instala Next.js y Prisma en tu proyecto:

    npx create-next-app@latest my-api
    cd my-api
    npm install @prisma/client prisma zod @node-rs/argon2
    npx prisma init
    
  2. Configura Prisma:

    En prisma/schema.prisma, define tu modelo de usuario:

    datasource db {
      provider = "postgresql"
      url      = env("DATABASE_URL")
    }
    
    model User {
      id             Int      @id @default(autoincrement())
      email          String   @unique
      hashedPassword String
      createdAt      DateTime @default(now())
    }
    

    Luego, ejecuta el siguiente comando para crear la base de datos:

    npx prisma migrate dev --name init
    
  3. Crea el cliente de Prisma una sola vez:

    Éste es el paso que más se salta, y el que causa el error too many connections en desarrollo. Con recarga en caliente, cada cambio crea un cliente nuevo y abre otra conexión. La solución es un singleton:

    // lib/db.ts
    import { PrismaClient } from "@prisma/client"
    
    const globalForPrisma = globalThis as unknown as {
      prisma: PrismaClient | undefined
    }
    
    export const db = globalForPrisma.prisma ?? new PrismaClient()
    
    if (process.env.NODE_ENV !== "production") {
      globalForPrisma.prisma = db
    }
    
  4. Crea el endpoint de registro:

    // app/api/auth/register/route.ts
    import { NextRequest } from "next/server"
    import { z } from "zod"
    import { hash } from "@node-rs/argon2"
    import { db } from "@/lib/db"
    
    const schema = z.object({
      email: z.string().email(),
      password: z.string().min(8),
    })
    
    export async function POST(request: NextRequest) {
      const body = await request.json().catch(() => null)
      const parsed = schema.safeParse(body)
    
      if (!parsed.success) {
        return Response.json({ error: "Datos inválidos" }, { status: 400 })
      }
    
      const existing = await db.user.findUnique({
        where: { email: parsed.data.email },
        select: { id: true },
      })
    
      // No confirmamos si el correo ya existe
      if (existing) {
        return Response.json({ error: "No se pudo registrar" }, { status: 409 })
      }
    
      const hashedPassword = await hash(parsed.data.password)
    
      const user = await db.user.create({
        data: { email: parsed.data.email, hashedPassword },
        select: { id: true, email: true, createdAt: true },
      })
    
      return Response.json({ user }, { status: 201 })
    }
    

    Fíjate en el select del create: sin él, la respuesta incluiría hashedPassword.

  5. Genera el token al iniciar sesión:

    import jwt from "jsonwebtoken"
    
    const token = jwt.sign({ sub: String(user.id) }, process.env.JWT_SECRET!, {
      expiresIn: "1h",
    })
    
  6. Protege tus endpoints:

    En el App Router no hay next(): un helper devuelve el usuario o una respuesta de error, y el handler decide.

    // lib/require-auth.ts
    import { NextRequest } from "next/server"
    import jwt from "jsonwebtoken"
    
    export function requireAuth(request: NextRequest) {
      const header = request.headers.get("authorization")
      const token = header?.startsWith("Bearer ") ? header.slice(7) : null
    
      if (!token) {
        return { error: Response.json({ error: "No autorizado" }, { status: 401 }) }
      }
    
      try {
        const payload = jwt.verify(token, process.env.JWT_SECRET!) as { sub: string }
        return { userId: Number(payload.sub) }
      } catch {
        return { error: Response.json({ error: "Token inválido" }, { status: 401 }) }
      }
    }
    

    Y en el handler, la parte que casi nadie escribe — la autorización por recurso:

    // app/api/pedidos/[id]/route.ts
    export async function GET(request: NextRequest, { params }) {
      const auth = requireAuth(request)
      if ("error" in auth) return auth.error
    
      const { id } = await params
    
      const pedido = await db.pedido.findFirst({
        // El dueño va en el WHERE, no en un if posterior
        where: { id: Number(id), userId: auth.userId },
      })
    
      if (!pedido) return Response.json({ error: "No encontrado" }, { status: 404 })
    
      return Response.json({ pedido })
    }
    

    Poner userId dentro del where en lugar de comparar después es lo que convierte "autenticado" en "autorizado", y devuelve 404 en lugar de 403 para no revelar que el recurso existe.

Hacia dónde va

El desarrollo de APIs REST está en constante evolución. Se espera que las APIs GraphQL continúen ganando terreno debido a su flexibilidad en la obtención de datos, aunque a costa de una superficie de ataque distinta y más difícil de limitar. Además, la adopción de microservicios y el uso de contenedores para desplegar APIs sigue creciendo, lo que permite mayor escalabilidad y facilidad de mantenimiento.

Conclusión

Construir una API REST segura con Next.js 15 y Prisma es un proceso que requiere atención a detalles clave como la autenticación, la autorización y la validación de datos. Siguiendo las mejores prácticas mencionadas, puedes crear una API que no solo sea funcional, sino también resistente frente a ataques.

Si te llevas solo tres cosas: el cliente de Prisma se crea una vez, no por petición; la validación va antes de tocar la base; y el dueño del recurso va dentro de la consulta, no en un if después. Esas tres cubren la mayoría de lo que se rompe en una API joven.