Deep Dive into Nested Routing with Django Rest Framework (DRF)

Nested routers in Django Rest Framework (DRF) allow you to define a hierarchical relationship between two or more resources in your API. This can be useful when you have resources that are related to each other, and you want to expose these relationships through your API endpoints.

Django Rest Framework (DRF) is a powerful tool for building RESTful APIs in Django applications. One of its advanced features is nested routing, which allows you to structure your API endpoints in a hierarchical manner. In this blog post, we’ll explore the concept of nested routing in DRF, discuss its advantages, and provide practical examples to demonstrate how it works.

Understanding Nested Routing

Nested routing in DRF involves defining API endpoints that are organized hierarchically. Instead of having a flat structure where all resources are at the same level, you can nest resources within one another. This closely mirrors relationships between models in your database, making your API more intuitive and expressive.

Advantages of Nested Routing

  • Logical Structure: Nested routing mirrors the relationships between your data models, making your API endpoints more intuitive for developers.
  • Reduces Repetition: You can reuse common URL patterns by nesting resources, reducing the need for redundant endpoints.
  • Data Integrity: Nested routing helps maintain data integrity, as it enforces constraints like foreign key relationships.
  • Simplified Code: Your code becomes cleaner and more maintainable as you encapsulate related functionality within nested views and serializers.

Implementing Nested Routing in DRF

To implement nested routing in DRF, you’ll need to define the routes, views, and serializers that correspond to your nested resources. Here’s a general outline of the steps involved:

  • Define the parent resource view (e.g., a list of authors).
  • Define the child resource view (e.g., a list of books belonging to an author).
  • Map the child view to the parent view using nested URL patterns.

Examples of Nested Routing

Let’s dive into practical examples of nested routing in DRF:

Nested Serializers

class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = '__all__'

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

class AuthorDetailView(generics.RetrieveAPIView):
    queryset = Author.objects.all()
    serializer_class = AuthorSerializer

class BookListView(generics.ListCreateAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

urlpatterns = [
    path('authors/', AuthorListView.as_view(), name='author-list'),
    path('authors/<int:pk>/', AuthorDetailView.as_view(), name='author-detail'),
    path('authors/<int:author_id>/books/', BookListView.as_view(), name='book-list'),

In this example, we’ve nested books under authors. You can retrieve a specific author’s books by accessing /authors/<author_id>/books/.

Nested Views

class AuthorViewSet(viewsets.ModelViewSet):
    queryset = Author.objects.all()
    serializer_class = AuthorSerializer

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

router = DefaultRouter()
router.register(r'authors', AuthorViewSet)

# Nested route registration
author_router = routers.NestedSimpleRouter(router, r'authors', lookup='author')
author_router.register(r'books', BookViewSet, basename='author-books')

urlpatterns = [
    path('', include(router.urls)),
    path('', include(author_router.urls)),

In this example, we use DRF’s NestedSimpleRouter to define nested routes for authors and their books. Accessing /authors/<author_id>/books/ will return a list of books by the specified author.

Complex Nested Structures

You can create complex nested structures with multiple levels of nesting, depending on your application’s requirements. This is especially useful for APIs dealing with intricate data models.

Best Practices for Nested Routing

  • Keep it Logical: Design your nested routes to reflect the relationships between your data models.
  • Use Permissions: Implement appropriate permissions and authentication to control access to nested resources.
  • Versioning: Consider API versioning strategies when using nested routes to maintain backward compatibility.


Nested routing in DRF is a powerful feature that allows you to create well-organized, expressive, and efficient RESTful APIs,. By mirroring your data model relationships in your API structure, you can make your code more intuitive and maintainable. With the examples and best practices discussed in this blog post, you’re well-equipped to leverage nested routing effectively in your Django Rest Framework projects.

Blogs You Might Like to Read!