FastAPI Auth JWT

Seamless, production-ready JWT authentication for your FastAPI applications.

---

Source Code	Documentation	PyPI	Live Demos
GitHub	Docs	PyPI	Examples

---

Table of Contents

• 🌟 Why FastAPI Auth JWT?
• 📦 Installation
• 🚀 Getting Started
  • 🛠️ 1. Define a User Model
  • ⚙️ 2. Configure Authentication Settings
  • 🔧 3. Initialize the Authentication Backend
  • 🔌 4. Add Middleware to FastAPI
  • 📚 5. Define Your Routes
• 🧰 Redis Extension
• ⚙️ Key Components & Configurations
• 📂 Example Projects
• 📚 Documentation
• 🛡️ License
• ⭐ Get Involved

---

🌟 Why FastAPI Auth JWT?

FastAPI Auth JWT empowers developers to implement secure, reliable, and efficient JWT-based authentication in their FastAPI applications. With minimal setup and deep customization options, it helps projects of all sizes establish trust, protect sensitive endpoints, and scale seamlessly.

• 🚀 Quick Setup: Integrate JWT authentication into new or existing FastAPI projects in just a few lines.
• 🛠️ Configurable & Extensible: Easily adapt authentication rules, user schemas, and token lifetimes to meet dynamic requirements.
• 🔄 Sync & Async Compatible: Whether your routes are synchronous or asynchronous, the middleware and backend integrate smoothly.
• 💾 Multiple Storage Backends: Start with in-memory caching for simplicity, then scale transparently to Redis for high-availability, distributed architectures.
• ✅ Thoroughly Tested & Documented: A well-structured codebase with comprehensive tests and clear documentation means you can rely on stable, predictable behavior.

---

📦 Installation

Basic Installation:

pip install fastapi-auth-jwt

With Redis Support:

pip install fastapi-auth-jwt[redis]

From Source:

1. Clone the repository:

   git clone https://github.com/deepmancer/fastapi-auth-jwt.git

2. Navigate to the directory:

   cd fastapi-auth-jwt

3. Install the package:

   pip install .

Requirements:

• Python 3.8+
• FastAPI 0.65.2+

---

🚀 Getting Started

Below is a high-level example to get you started. For more advanced use cases and patterns, refer to the examples section and the official docs.

🛠️ 1. Define a User Model

Create a simple Pydantic model representing your user entity.

from pydantic import BaseModel, Field
from typing import Optional

class User(BaseModel):
    username: str
    password: str
    token: Optional[str] = Field(None)

⚙️ 2. Configure Authentication Settings

Specify your JWT signing secrets, algorithms, and token expiration times.

from pydantic import BaseModel

class AuthenticationSettings(BaseModel):
    secret: str = "your-secret-key"
    jwt_algorithm: str = "HS256"
    expiration_seconds: int = 3600  # 1 hour

🔧 3. Initialize the Authentication Backend

Integrate the JWTAuthBackend using your settings and user schema.

from fastapi_auth_jwt import JWTAuthBackend

auth_backend = JWTAuthBackend(
    authentication_config=AuthenticationSettings(),
    user_schema=User
)

🔌 4. Add Middleware to FastAPI

Hook the authentication middleware into your application.

from fastapi import FastAPI
from fastapi_auth_jwt import JWTAuthenticationMiddleware

app = FastAPI()

app.add_middleware(
    JWTAuthenticationMiddleware,
    backend=auth_backend,
    exclude_urls=["/sign-up", "/login"],  # Public endpoints
)

📚 5. Define Your Routes

Secure routes automatically validate tokens before accessing the request state.

@app.post("/sign-up")
async def sign_up(user: User):
    # Implement user creation logic here
    return {"message": "User created"}

@app.post("/login")
async def login(user: User):
    token = await auth_backend.create_token(
        {"username": user.username, "password": user.password},
        expiration=3600
    )
    return {"token": token}

@app.get("/profile-info")
async def get_profile_info(request):
    user = request.state.user
    return {"username": user.username}

@app.post("/logout")
async def logout(request):
    user = request.state.user
    await auth_backend.invalidate_token(user.token)
    return {"message": "Logged out"}

---

🧰 Redis Extension

For production environments that require robust session management, enable Redis-backed storage:

from fastapi_auth_jwt import RedisConfig, JWTAuthBackend

redis_config = RedisConfig(
    host="localhost",
    port=6379,
    db=0
)

auth_backend_redis = JWTAuthBackend(
    authentication_config=AuthenticationSettings(),
    user_schema=User,
    storage_config=redis_config,
)

app.add_middleware(
    JWTAuthenticationMiddleware,
    backend=auth_backend_redis,
    exclude_urls=["/sign-up", "/login"]
)

---

⚙️ Key Components & Configurations

AuthenticationSettings:

• secret: JWT signing secret.
• jwt_algorithm: Algorithm for token signing (default: "HS256").
• expiration_seconds: Token validity period in seconds.

StorageConfig:

• storage_type: Set to MEMORY or REDIS for distributed environments.

RedisConfig:

• host, port, db: Core Redis connection parameters.
• password: Optional if your Redis server requires it.

With these configurations, you can tailor your authentication layer to match your exact operational needs—be it local development, CI/CD pipelines, or full-scale production deployments.

---

📂 Example Projects

Check out the examples directory for ready-to-run scenarios, including both standard and Redis-backed workflows. Each example demonstrates best practices for integrating JWT authentication into real-world FastAPI applications.

---

📚 Documentation

Extensive and continuously updated documentation is available at the official docs. There you will find detailed setup guides, API references, configuration tips, and troubleshooting advice.

---

🛡️ License

This project is licensed under the MIT License. See the LICENSE file for more details.

---

⭐ Get Involved

Your feedback and contributions are welcome! Here’s how you can support and shape the future of FastAPI Auth JWT:

• ⭐ Star this repository to stay informed and show appreciation.
• 🖇️ Fork the project and experiment with new ideas.
• 🐛 Report Issues or request enhancements via GitHub Issues.
• 🤝 Contribute code, documentation, or examples to help others learn and succeed.
• 📬 Reach Out with questions, suggestions, or integration stories.

---

With FastAPI Auth JWT, you can implement secure, stable, and scalable JWT authentication in minutes—focusing on building great features instead of reinventing authentication logic.