← BACK_TO_LOGS

Mastering Next.js Authentication with JWT

•3 min read•KANAT NAZAROV

Mastering Next.js Authentication with JWT

Authentication is the cornerstone of any modern web application. If you're developing with Next.js, JWT (JSON Web Tokens) provides a robust solution for managing user sessions. Let's dive into how you can implement JWT authentication in a Next.js app, address common pitfalls, and ensure security.

Why Choose JWT?

JWTs are compact, URL-safe tokens that are easy to pass between client and server. They help with maintaining stateless authentication sessions, which is ideal for scaling applications. Their structure consists of three parts: Header, Payload, and Signature, allowing for easy validation.

Setting Up Next.js for JWT

First, ensure you have a Next.js application ready. If not, spin one up using:

npx create-next-app@latest my-nextjs-app
cd my-nextjs-app

Installing Required Packages

You'll need

jsonwebtoken
for creating and verifying JWTs, and
next-connect
for handling API routes more elegantly:

npm install jsonwebtoken next-connect

Creating JWT Tokens

Let's set up an API route to handle user login and token generation:

// pages/api/login.ts
import { NextApiRequest, NextApiResponse } from 'next';
import jwt from 'jsonwebtoken';

const secret = process.env.JWT_SECRET || 'your-secret-key';

export default (req: NextApiRequest, res: NextApiResponse) => {
  if (req.method === 'POST') {
    const { username, password } = req.body;

    // Assume validation happens here
    if (username === 'admin' && password === 'password') {
      const token = jwt.sign({ username }, secret, { expiresIn: '1h' });
      return res.status(200).json({ token });
    }

    return res.status(401).json({ error: 'Invalid credentials' });
  }

  res.setHeader('Allow', ['POST']);
  res.status(405).end(`Method ${req.method} Not Allowed`);
};

Important Considerations

  • Secret Key: Always keep your secret key safe and out of your codebase. Use environment variables.
  • Expiration: Tokens should have an expiration time to reduce risk if they are leaked.

Middleware for Protecting Routes

To protect certain routes, you can use middleware to verify the JWT:

// middleware/auth.ts
import { NextApiRequest, NextApiResponse } from 'next';
import jwt from 'jsonwebtoken';

const secret = process.env.JWT_SECRET || 'your-secret-key';

export const authMiddleware = (handler: any) => {
  return async (req: NextApiRequest, res: NextApiResponse) => {
    const token = req.headers.authorization?.split(' ')[1];

    if (!token) {
      return res.status(401).json({ error: 'Token required' });
    }

    try {
      jwt.verify(token, secret);
      return handler(req, res);
    } catch (err) {
      return res.status(401).json({ error: 'Invalid or expired token' });
    }
  };
};

Applying the Middleware

Use this middleware in any API route you want to protect:

// pages/api/protected.ts
import { NextApiRequest, NextApiResponse } from 'next';
import { authMiddleware } from '../../middleware/auth';

const handler = (req: NextApiRequest, res: NextApiResponse) => {
  res.status(200).json({ message: 'This is a protected route' });
};

export default authMiddleware(handler);

Addressing Common Pitfalls

Token Revocation

Stateless nature of JWT means revocation is tricky. Consider implementing a token blacklist if you need to immediately revoke tokens.

Secure Token Storage

  • Client-Side: Store tokens in
    httpOnly
    cookies to mitigate XSS attacks.
  • Server-Side: Always validate tokens on the server.

Error Handling

Ensure your application gracefully handles errors, especially around authentication failures. Always inform users about expired sessions or invalid tokens without exposing sensitive details.

Enhancing Security

  • Use HTTPS: Always serve your application over HTTPS to encrypt token transmission.
  • Short-Lived Tokens: The shorter the token lifespan, the better.
  • Refresh Tokens: Implement refresh tokens to extend user sessions securely.

Conclusion

Implementing JWT authentication in Next.js isn't just about generating tokens. It's about ensuring secure, scalable, and robust authentication. By considering the nuances of token management, middleware usage, and security best practices, you can create a seamless authentication experience.

Stay vigilant with security updates and always test your authentication logic thoroughly. Your users’ trust is paramount, and with JWT, you have a powerful tool to maintain that trust.

Leave a comment

Kanat Nazarov

Kanat Nazarov

Systems & Full-Stack Engineer
Kanat Nazarov is a product-minded Full-Stack Engineer. He is the co-founder of GetFusionChat, an enterprise-grade multi-tenant communication SaaS platform. Beyond architecting low-latency infrastructures and advanced AI systems, Kanat is a dedicated student of peak performance—optimizing his lifestyle through rigorous fitness, precise nutrition, and creative production in music. He operates on the core philosophy that breakthrough technical results stem from a high-functioning, deeply disciplined life.