Guide to Django Rest Framework Function-Based Views with Examples

Django Rest Framework (DRF) is a powerful and flexible toolkit for building Web APIs in Django applications. It simplifies the process of creating APIs by providing a set of tools and abstractions that make it easier to handle common tasks, such as serialization, authentication, and pagination. While DRF offers both class-based and function-based views for building APIs, in this blog, we’ll focus on function-based views (FBVs).

Function-based views offer a simpler and more concise way to define API endpoints compared to class-based views. They are particularly useful for small to medium-sized projects or when you want to create custom and highly specialized views. In this guide, we’ll explore the basics of DRF function-based views with examples.

You can read more on Class Based Views in DRF

Setting Up Your Django Project

Before we dive into function-based views, let’s ensure you have a Django project set up with Django Rest Framework installed. If you haven’t already, you can create a new Django project and install DRF by running the following commands:

django-admin startproject project_name
cd project_name
python startapp api
pip install djangorestframework

Now that your Django project is set up, let’s create a simple API using function-based views.

Creating a Function-Based View

To create a function-based view, you’ll need to define a Python function that takes at least one argument (usually named request) representing the incoming HTTP request. You then return an HTTP response, typically serialized data using DRF serializers.

Let’s create a simple view that returns a list of items as JSON. First, define a model and serializer:

# api/
from django.db import models

class Item(models.Model):
    name = models.CharField(max_length=100)
    description = models.TextField()

# api/
from rest_framework import serializers
from .models import Item

class ItemSerializer(serializers.ModelSerializer):
    class Meta:
        model = Item
        fields = '__all__'

Now, create a function-based view that lists all items:

# api/
from rest_framework.decorators import api_view
from rest_framework.response import Response
from .models import Item
from .serializers import ItemSerializer

def item_list(request):
    items = Item.objects.all()
    serializer = ItemSerializer(items, many=True)
    return Response(

In this example, we use the @api_view decorator to specify that this function-based view should only respond to HTTP GET requests.

Wiring URLs to Function-Based Views

To make your function-based view accessible through an API endpoint, you need to wire it up to a URL. Modify your project’s file as follows:

# project_name/
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('api/', include('api.urls')),  # Include your app's URLs

Then, create a file within your app (api/ and define the URL pattern for the function-based view:

# api/
from django.urls import path
from . import views

urlpatterns = [
    path('items/', views.item_list, name='item_list'),

Testing Your Function-Based View

With everything set up, you can now test your function-based view. Start your Django development server:

python runserver

Access the URL http://localhost:8000/api/items/ in your browser or use a tool like curl or Postman to make GET requests. You should receive a JSON response with a list of items.

That’s it! You’ve created a simple API endpoint using a Django Rest Framework function-based view.


Django Rest Framework function-based views offer a straightforward way to build API endpointts in your Django projects. They are specially useful when you want to keep your code concise and tailored to specific requirements. In this guide, we’ve covered the basics of creating function-based views, defining serializers, wiring URLs, and testing your API endpoint. With these concepts in hand, you can expand your API and build more complex functionality as needed in your Django project.