FastAPI JWT Authentication Skill

When to Use This Skill

• User wants to implement JWT authentication in FastAPI
• Need to secure API endpoints with token-based authentication
• Want to implement user registration and login functionality
• Looking for OAuth2 password flow implementation
• Need to set up password hashing and verification

How This Skill Works (Step-by-Step Execution)

1. Dependency Installation

- Install pyjwt, pwdlib[argon2], and other required packages - Set up environment variables for secret keys

1. User Model and Database Setup

- Create User model with proper fields - Set up database connection and session management - Implement password hashing utilities

1. JWT Token Generation

- Create token generation function with proper expiration - Implement OAuth2PasswordBearer security scheme - Add token verification utilities

1. Authentication Endpoints

- Create /token endpoint for login - Implement user retrieval and validation - Add protected route examples

1. Security Implementation

- Add proper error handling for authentication failures - Implement user isolation - Configure security headers

Output You Will Receive

After activation, I will deliver:

• Complete dependency installation commands
• User model and database setup
• JWT token generation and verification functions
• Login endpoint with proper error handling
• Protected route examples
• Security best practices and configurations

Example Usage

User says: "I need to add JWT authentication to my FastAPI application."

This Skill Instantly Activates → Delivers:

• Complete dependency setup with pyjwt and pwdlib
• User model with proper password hashing
• OAuth2 password flow implementation
• Token generation and verification functions
• Protected route examples
• Security best practices

User says: "Secure my API endpoints with JWT tokens in FastAPI."

This Skill Responds: → Sets up OAuth2PasswordBearer security scheme → Creates token generation endpoint → Implements JWT verification middleware → Provides protected route examples with user isolation

Activate This Skill By Saying

• "Add JWT authentication to my FastAPI app"
• "Secure my API endpoints with JWT tokens"
• "Implement login and registration in FastAPI"
• "I need OAuth2 password flow in FastAPI"

Core Implementation Steps

1. Install Dependencies

pip install pyjwt pwdlib[argon2]

2. User Model and Password Hashing

from pwdlib import PasswordHash
from typing import Annotated
from fastapi import Depends, FastAPI, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from pydantic import BaseModel

password_hash = PasswordHash.recommended()

def hash_password(password: str):
    return password_hash.hash(password)

def verify_password(password: str, hashed_password: str):
    return password_hash.verify(password, hashed_password)

3. JWT Token Generation

from datetime import datetime, timedelta
import jwt

SECRET_KEY = "your-secret-key"  # Use environment variable
ALGORITHM = "HS256"

def create_access_token(data: dict, expires_delta: timedelta = None):
    to_encode = data.copy()
    if expires_delta:
        expire = datetime.utcnow() + expires_delta
    else:
        expire = datetime.utcnow() + timedelta(minutes=15)
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

4. Authentication Endpoint

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

@app.post("/token")
async def login(form_data: Annotated[OAuth2PasswordRequestForm, Depends()]):
    user = fake_users_db.get(form_data.username)
    if not user or not verify_password(form_data.password, user["hashed_password"]):
        raise HTTPException(status_code=400, detail="Incorrect username or password")

    access_token_expires = timedelta(minutes=30)
    access_token = create_access_token(
        data={"sub": user["username"]}, expires_delta=access_token_expires
    )
    return {"access_token": access_token, "token_type": "bearer"}

5. Protected Route

async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]):
    credentials_exception = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Could not validate credentials",
        headers={"WWW-Authenticate": "Bearer"},
    )
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        username: str = payload.get("sub")
        if username is None:
            raise credentials_exception
    except jwt.PyJWTError:
        raise credentials_exception
    user = get_user(username=username)
    if user is None:
        raise credentials_exception
    return user

@app.get("/users/me")
async def read_users_me(current_user: User = Depends(get_current_user)):
    return current_user