Building REST APIs with Django

# CHAPTER 15

Building REST APIs with Django #

1. Introduction #

2. Learning Objectives #

• Understand the purpose of a REST API in a decoupled architecture.

• Install and configure Django REST Framework (DRF).

• Create a ModelSerializer to convert Python objects to JSON.

• Build class-based API Views.

• Test endpoints using the DRF Browsable API interface.

3. Beginner-Friendly Explanation #

4. Step 1: Installing Django REST Framework #

pip install djangorestframework

Register the framework in your core/settings.py file:

INSTALLED_APPS = [
    # ... built-in apps
    'blog',
    'rest_framework', # Add DRF here
]

5. Step 2: Creating a Serializer #

Create a new file: blog/serializers.py

from rest_framework import serializers
from .models import Post

class PostSerializer(serializers.ModelSerializer):
    class Meta:
        model = Post
        # Specify the columns to include in the JSON payload
        fields = ['id', 'title', 'content', 'author', 'date_posted']

6. Step 3: Building the API View #

Update blog/views.py:

from rest_framework.decorators import api_view
from rest_framework.response import Response
from .models import Post
from .serializers import PostSerializer

# The @api_view decorator enforces that this route only accepts GET requests
@api_view(['GET'])
def api_post_list(request):
    # 1. Query the database
    posts = Post.objects.all()
    
    # 2. Pass the QuerySet into the Translator. 
    # many=True tells DRF we are translating a list of objects, not just one.
    serializer = PostSerializer(posts, many=True)
    
    # 3. Return the universal JSON data!
    return Response(serializer.data)

7. Step 4: Routing the API #

Update blog/urls.py:

from django.urls import path
from . import views

urlpatterns = [
    # Your standard HTML routes...
    path('', views.home, name='blog-home'),
    
    # The new JSON API endpoint
    path('api/posts/', views.api_post_list, name='api-post-list'),
]

8. Testing the API #

You will be greeted by the DRF Browsable API. Instead of a raw, ugly wall of JSON text, DRF provides a beautiful, interactive webpage where you can view the JSON payload and even test POST requests directly from the browser without needing tools like Postman!

*The raw output looks like this:*

[
    {
        "id": 1,
        "title": "My First Post",
        "content": "Hello World",
        "author": 1,
        "date_posted": "2026-10-12T14:30:00Z"
    }
]

9. Backend Workflow: Full CRUD with Generic Views #

from rest_framework import generics

# This automatically handles GET (List) and POST (Create)
class PostListAPIView(generics.ListCreateAPIView):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

*This is the true power of Django REST Framework. Massive functionality with minimal code.*

10. Best Practices #

• API Versioning: Just like in Node.js, always version your APIs. In the master urls.py, route traffic like this: path('api/v1/', include('blog.urls')). This ensures that if you completely redesign the API next year (v2), the legacy mobile apps relying on v1 won't crash.

11. Common Mistakes #

• Forgetting many=True: When querying a list of objects (Post.objects.all()), if you forget to pass the many=True argument to the Serializer, DRF will crash because it expects a single object but received a list.

12. Exercises #

1. 1. Explain the conceptual relationship between a Django ModelForm (used for HTML pages) and a DRF ModelSerializer (used for APIs). How are their primary tasks similar?

13. Coding Challenges #

• Challenge: Using the @apiview(['GET']) decorator, write a detail endpoint apipost_detail(request, pk) that fetches a single post by its Primary Key (pk). Pass the single object to the Serializer (do *not* use many=True), and return the Response.

14. MCQs with Answers #

15. Interview Questions #

• Q: Explain why Django developers rely on the Django REST Framework (DRF) package instead of simply using Python's built-in json module to serialize data manually.

• Q: Describe how a decoupled architecture works (e.g., a React frontend communicating with a Django DRF backend). What are the advantages of this approach over traditional server-side rendering (SSR) using Django templates?

16. FAQs #

17. Summary #

18. Next Chapter Recommendation #