Django REST Framework vs Django Ninja: A Comprehensive Comparison for API Development

Question

When building APIs with Django, developers typically face a choice between two powerful frameworks: Django REST Framework (DRF) and Django Ninja. Both serve the same fundamental purpose—creating robust REST APIs—but take dramatically different approaches to achieve this goal.

This tutorial provides an in-depth technical comparison to help you choose the right tool for your project.

Quick Overview

Django REST Framework (DRF)

Mature, battle-tested framework (2011)
Django-native approach with class-based views
Extensive ecosystem and third-party packages
Powerful serialization and validation system
Built-in authentication, permissions, and pagination

Django Ninja

Modern framework inspired by FastAPI (2021)
Type hints and automatic documentation
Performance-focused with async support
Lightweight and intuitive API design
Built-in OpenAPI/Swagger documentation

KFSys · Answer

Architecture and Philosophy

Django REST Framework: The Django Way

DRF follows Django’s philosophy closely, extending Django’s patterns into the API realm:

# DRF ViewSet approach
from rest_framework import viewsets, serializers
from rest_framework.response import Response
from .models import Book

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = '__all__'

class BookViewSet(viewsets.ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    def create(self, request):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        book = serializer.save()
        return Response(serializer.data, status=201)

Django Ninja: The FastAPI-Inspired Approach

Ninja embraces modern Python features and prioritizes developer experience:

# Django Ninja approach
from ninja import NinjaAPI, Schema
from typing import List
from .models import Book

api = NinjaAPI()

class BookSchema(Schema):
    title: str
    author: str
    isbn: str
    published_date: date

class BookOut(Schema):
    id: int
    title: str
    author: str
    isbn: str

@api.post("/books", response=BookOut)
def create_book(request, book: BookSchema):
    book_instance = Book.objects.create(**book.dict())
    return book_instance

Performance Comparison

Benchmarks and Overhead

Django Ninja generally outperforms DRF in raw throughput:

# Performance test setup
import time
from django.test import TestCase, Client

class PerformanceTest(TestCase):
    def setUp(self):
        self.client = Client()
        # Create test data
        for i in range(1000):
            Book.objects.create(
                title=f"Book {i}",
                author=f"Author {i}",
                isbn=f"978-{i:010d}"
            )

    def test_list_performance(self):
        # DRF endpoint
        start = time.time()
        response = self.client.get('/api/drf/books/')
        drf_time = time.time() - start

        # Ninja endpoint
        start = time.time()
        response = self.client.get('/api/ninja/books/')
        ninja_time = time.time() - start

        print(f"DRF: {drf_time:.4f}s, Ninja: {ninja_time:.4f}s")

Typical Results:

Django Ninja: ~20-30% faster for simple CRUD operations
DRF: Comparable performance with heavy serialization logic
Async operations: Ninja has significant advantages

Memory Usage

# Memory profiling example
import tracemalloc

tracemalloc.start()

# Your API calls here
response = client.get('/api/books/')

current, peak = tracemalloc.get_traced_memory()
print(f"Current memory usage: {current / 1024 / 1024:.2f} MB")
print(f"Peak memory usage: {peak / 1024 / 1024:.2f} MB")

Type Safety and Validation

DRF Serializers vs Ninja Schemas

DRF Validation:

class BookSerializer(serializers.ModelSerializer):
    title = serializers.CharField(max_length=200)
    isbn = serializers.CharField(validators=[isbn_validator])

    class Meta:
        model = Book
        fields = ['title', 'author', 'isbn', 'published_date']

    def validate_isbn(self, value):
        if not value.startswith('978'):
            raise serializers.ValidationError("ISBN must start with 978")
        return value

    def validate(self, data):
        if data['published_date'] > timezone.now().date():
            raise serializers.ValidationError("Publication date cannot be in the future")
        return data

Ninja Schema Validation:

from pydantic import validator
from datetime import date

class BookSchema(Schema):
    title: str = Field(..., max_length=200)
    author: str
    isbn: str
    published_date: date

    @validator('isbn')
    def validate_isbn(cls, v):
        if not v.startswith('978'):
            raise ValueError('ISBN must start with 978')
        return v

    @validator('published_date')
    def validate_publication_date(cls, v):
        if v > date.today():
            raise ValueError('Publication date cannot be in the future')
        return v

Authentication and Permissions

DRF Authentication System

from rest_framework.authentication import TokenAuthentication
from rest_framework.permissions import IsAuthenticated
from rest_framework.decorators import action

class BookViewSet(viewsets.ModelViewSet):
    authentication_classes = [TokenAuthentication]
    permission_classes = [IsAuthenticated]

    @action(detail=True, methods=['post'])
    def set_favorite(self, request, pk=None):
        book = self.get_object()
        # Custom logic here
        return Response({'status': 'favorite set'})

Ninja Authentication

from ninja.security import HttpBearer
from django.contrib.auth import authenticate

class AuthBearer(HttpBearer):
    def authenticate(self, request, token):
        try:
            user = Token.objects.get(key=token).user
            return user
        except Token.DoesNotExist:
            return None

@api.post("/books", auth=AuthBearer())
def create_book(request, book: BookSchema):
    # request.auth contains the authenticated user
    return Book.objects.create(**book.dict())

Advanced Features Comparison

Filtering and Searching

DRF with django-filter:

from django_filters.rest_framework import DjangoFilterBackend
from rest_framework.filters import SearchFilter

class BookViewSet(viewsets.ModelViewSet):
    filter_backends = [DjangoFilterBackend, SearchFilter]
    filterset_fields = ['author', 'published_date']
    search_fields = ['title', 'author']

    def get_queryset(self):
        queryset = Book.objects.all()
        author = self.request.query_params.get('author')
        if author:
            queryset = queryset.filter(author__icontains=author)
        return queryset

Ninja Filtering:

from ninja import Query

@api.get("/books")
def list_books(request,
               author: str = Query(None),
               search: str = Query(None),
               limit: int = Query(10)):
    books = Book.objects.all()

    if author:
        books = books.filter(author__icontains=author)
    if search:
        books = books.filter(title__icontains=search)

    return books[:limit]

Pagination

DRF Pagination:

from rest_framework.pagination import PageNumberPagination

class BookPagination(PageNumberPagination):
    page_size = 20
    page_size_query_param = 'page_size'
    max_page_size = 100

class BookViewSet(viewsets.ModelViewSet):
    pagination_class = BookPagination

Ninja Pagination:

@api.get("/books")
def list_books(request,
               page: int = Query(1),
               page_size: int = Query(20)):
    offset = (page - 1) * page_size
    books = Book.objects.all()[offset:offset + page_size]
    total = Book.objects.count()

    return {
        "items": books,
        "total": total,
        "page": page,
        "pages": (total + page_size - 1) // page_size
    }

Testing Strategies

DRF Testing

from rest_framework.test import APITestCase
from rest_framework import status

class BookAPITest(APITestCase):
    def setUp(self):
        self.user = User.objects.create_user('testuser', 'test@test.com', 'pass')
        self.client.force_authenticate(user=self.user)

    def test_create_book(self):
        data = {
            'title': 'Test Book',
            'author': 'Test Author',
            'isbn': '9781234567890'
        }
        response = self.client.post('/api/books/', data)
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        self.assertEqual(Book.objects.count(), 1)

Ninja Testing

from django.test import TestCase, Client

class BookNinjaTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = User.objects.create_user('testuser', 'test@test.com', 'pass')

    def test_create_book(self):
        self.client.force_login(self.user)
        data = {
            'title': 'Test Book',
            'author': 'Test Author',
            'isbn': '9781234567890'
        }
        response = self.client.post('/api/books/',
                                  data=json.dumps(data),
                                  content_type='application/json')
        self.assertEqual(response.status_code, 201)

Community and Ecosystem