Deploy your apps to a supercloud in a few clicks

This Engineering Education program is supported by Section. Instantly deploy your GitHub apps, Docker containers or K8s namespaces to a supercloud.

Try It For Free

How to Build a Notes app API using Django REST Framework and MongoDB

May 17, 2021

MongoDB is a NoSQL database package. It keeps data in JSON-like format instead of the traditional row-column format. The Django REST framework is a robust package of tools for building extensible APIs. Django is one of the most well-liked packages that Python developers use to build websites.

You will learn how to use the powerful Django REST framework and MongoDB in your web projects. You will learn how to build CRUD features in a notes app.

In this article, you will:

  • Understand to integrate MongoDB into Django projects.
  • Learn how to set up and run Django REST API.
  • Create CRUD features in Django REST API.
  • Build a Notes app API.


To follow this article along it is important to have the following:

Setting up the MongoDB server

You may download and install the MongoDB database server from the official MongoDB website.

You can check this guide if you use a Windows machine, Installing MongoDB on Windows.

For Linux users, follow this tutorial, How to Install MongoDB on Ubuntu 20.04.

Mac users can follow the tutorial, Installing MongoDB on Mac

You can check the version of MongoDB installed on your machine with the following command:

mongo --version

To use the mongo shell, start the service with the following command:


Create and switch to a new database with the following command:

use notes_database

MongoDB Compass is a GUI tool that enables you to interact with MongoDB. You can view and operate your MongoDB databases with MongoDB Compass.

MongoDB Compass is available for download on the official website, Download and Install Compass.

Setting up the virtual environment

We will install virtualenv to enable a virtual environment for our project. It will enable one to isolate a project and its dependencies from other projects on your machine.

Run the following command to install virtualenv:

python -m pip install --user virtualenv

Next, let’s create a folder for our project and then create a virtual environment inside it.

Create a folder called django_mongodb_project as such:

mkdir django_mongodb_project

Move into the project folder with the following command:

cd django_mongodb_project

Create a virtual environment called venv with the following command:

virtualenv venv

Next, activate the environment:

source venv/bin/activate

If you use Windows, activate the virtual environment with the following command:


Install packages

We will need the django, djangorestframework, and djongo packages.

  • django: the Django framework package.
  • djangorestframework: the Django REST Framework for developing APIs in Django.
  • djongo: a tool that maps Python objects to MongoDB documents.

Let’s install Django and the Django REST framework with the following command:

pip install django django-rest-framework djongo

Now, create a Django project called notes_app:

django-admin startproject notes_app
cd notes_app

Then, create an app called api inside the notes_app project.

django-admin startapp api

Navigate to the file inside the project-level folder. Then, change the INSTALLED_APPS list by adding our created app, api and rest_framework:


Configuring MongoDB

Navigate to the file and change the DATABASES setting as follows:

   'default' : {
      'ENGINE' : 'djongo',
      'NAME' : 'notes_database'

Building the notes app via API

We will develop an API for a notes app to jot and take notes down. Users will be able to take notes, get a list of notes they made, and delete the notes.

Let’s define a model for the notes in the file of the api app that we have created:

from django.db import models
class Note(models.Model):
    title = models.CharField(max_length=50)
    text = models.TextField()
    def __str__(self):
        return self.title

Let’s migrate the model into the database:

python makemigrations
python migrate

Next, let’s create a serializer class. When users make requests to the API, the serializers format the corresponding responses. Create a new file in the api app folder. Make the necessary imports as demonstrated below and create the NoteSerializer class.

from rest_framework import serializers
from .models import Note
class NoteSerializer(serializers.ModelSerializer):
    class Meta:
        model = Note
        fields = ('id', 'title', 'text')

Next, let’s create the views that will handle the request and response actions of our API. Create the NoteList and NoteDetail views in the file of the api app.

from rest_framework import generics
from .models import Note
from .serializers import NoteSerializer
class NoteList(generics.ListCreateAPIView):
    queryset = Note.objects.all()
    serializer_class = NoteSerializer
class NoteDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = Note.objects.all()
    serializer_class = NoteSerializer

In the code above, we created two views. NoteList enables us to create a note and also view a list of created notes. NoteDetail allows us to view a particular note, update or delete it.

Next, we will create endpoints to receive requests. Create a new file inside the api directory.

Create the urlpatterns as follows inside:

from django.urls import path
from api import views
urlpatterns = [
    path('', views.NoteList.as_view()),
    path('<int:pk>/', views.NoteDetail.as_view()),

Next, set up the file of the project to point to the app level urlpatterns. Then, include a path to the file of the api app.

from django.contrib import admin
from django.urls import path, include
urlpatterns = [
    path('api/', include('api.urls')),  # add this line

The first endpoint receives the actions ‘LIST’ and ‘CREATE’ actions of the NoteList view. The second endpoint takes the id of a particular note to view the details of the note.

Testing with browsable API

Django REST framework comes shipped with the browsable API. You can test your API endpoints with the browsable API.

Activate the test server:

python runserver

Then navigate to on your browser to create notes.

image title

You can add notes and refresh the webpage to see the added notes.

image title

Then, view the created notes at

image title

You can also delete or update the note on the detail page. The red square in the next image contains the delete button.

image title

You can also update the title or text of the note. See the blue square area on the image above. Edit the text or title and click the ‘PUT` button.


This article described how to configure the MongoDB database for a RESTful Django API. We also created an API for a Notes app. You may go on and use MongoDB in your Django REST API projects.’

You may check out the example code in the GitHub repo.

Thanks for reading.

Happy coding!

Peer Review Contributions by: Geoffrey Mungai