Bharat Bhushan
Bharat Bhushan Founder of and Developing professional content for professionals 6 min read

MongoDB + Django Rest Framework CRUD Rest API example

In this tutorial, we’re gonna create Python/Django & MongoDB CRUD example with Django Rest Framework for building Rest Apis. You’ll know:

  • How to setup Django to connect with MongoDB Database
  • How to define Data Models and migrate it to MongoDB
  • Way to use Django Rest Framework to process HTTP requests
  • Way to make Django CRUD Operations with MongoDB Database

Related Post: Django CRUD with MySQL example | Django Rest Framework

Django + Angular 8
Django + React
Django + Vue.js

Django MongoDB CRUD Rest API overview

We will build Rest Apis using Django Rest Framework that can create, retrieve, update, delete and find Tutorials by title or published status.

First, we setup Django Project with a MongoDB Connector. Next, we create Rest Api app, add it with Django Rest Framework to the project. Next, we define data model and migrate it to the database. Then we write API Views and define Routes for handling all CRUD operations (including custom finder).

The following table shows overview of the Rest APIs that will be exported:

Methods Urls Actions
GET api/tutorials get all Tutorials
GET api/tutorials/:id get Tutorial by id
POST api/tutorials add new Tutorial
PUT api/tutorials/:id update Tutorial by id
DELETE api/tutorials/:id remove Tutorial by id
DELETE api/tutorials remove all Tutorials
GET api/tutorials/published find all published Tutorials
GET api/tutorials?title=[kw] find all Tutorials which title contains 'kw'

Finally, we’re gonna test the Rest Apis using Postman.


  • Python 3.7
  • Django 2.1.15
  • Django Rest Framework 3.11.0
  • djongo 1.3.1
  • django-cors-headers 3.2.1
  • MongoDB 3.4 or higher

Project structure

This is the directory structure of our Django Project:


Let me explain it briefly.

  • tutorials/ declares TutorialsConfig class (subclass of django.apps.AppConfig) that represents Rest CRUD Apis app and its configuration.
  • DjangoRestApiMongoDB/ contains settings for our Django project: MongoDB Database engine, INSTALLED_APPS list with Django REST framework, Tutorials Application, CORS and MIDDLEWARE.
  • tutorials/ defines Tutorial data model class (subclass of django.db.models.Model).
  • migrations/ is created when we make migrations for the data model, and will be used for generating MongoDB database collection.
  • tutorials/ manages serialization and deserialization with TutorialSerializer class (subclass of rest_framework.serializers.ModelSerializer).
  • tutorials/ contains functions to process HTTP requests and produce HTTP responses (using TutorialSerializer).
  • tutorials/ defines URL patterns along with request functions in the Views.
  • DjangoRestApiMongoDB/ also has URL patterns that includes tutorials.urls, it is the root URL configurations.

Install Django REST framework

Django REST framework helps us to build RESTful Web Services flexibly.

To install this package, run command:
pip install djangorestframework

Setup new Django project

Let’s create a new Django project with command:

django-admin startproject DjangoRestApiMongoDB

You can see the following folder tree when the process is done.


Now open and add Django REST framework to the INSTALLED_APPS array here.

	  # Django REST framework 

Connect Django project to MongoDB database

We need a Django MongoDb connector to work with MongoDb database.
In this tutorial, we’re gonna use djongo.

Run the command: pip install djongo.

Then we need to setup MongoDb Database engine.
So open and change declaration of DATABASES:

	  'default': {
		  'ENGINE': 'djongo',
		  'NAME': 'designmycodes_db',
		  'HOST': '',
		  'PORT': 27017,

Setup new Django app for Rest CRUD Api

Run following commands to create new Django app tutorials:

cd DjangoRestApiMongoDB
  python startapp tutorials

The project directory now looks like:


Open tutorials/, you can see TutorialsConfig class (subclass of django.apps.AppConfig). This is the Django app and its configuration that we’ve just created.

from django.apps import AppConfig
  class TutorialsConfig(AppConfig):
	  name = 'tutorials'

Don’t forget to add this app to INSTALLED_APPS array in

	  # Tutorials application 

Configure CORS and middleware

We need to allow requests to our Django application from other origins.
In this example, we’re gonna configure CORS to accept requests from localhost:8081.

First, install the django-cors-headers library:
pip install django-cors-headers

In, add configuration for CORS:

	  # CORS

You also need to add a middleware class to listen in on responses:

	  # CORS

Note: CorsMiddleware should be placed as high as possible, especially before any middleware that can generate responses such as CommonMiddleware.


  • CORS_ORIGIN_ALLOW_ALL: If True, all origins will be accepted (not use the whitelist below). Defaults to False.
  • CORS_ORIGIN_WHITELIST: List of origins that are authorized to make cross-site HTTP requests. Defaults to [].

Define the Django Model

Open tutorials/, add Tutorial class as subclass of django.db.models.Model.
There are 3 fields: title, description, published.

from django.db import models
  class Tutorial(models.Model):
	  title = models.CharField(max_length=70, blank=False, default='')
	  description = models.CharField(max_length=200,blank=False, default='')
	  published = models.BooleanField(default=False)

Each field is specified as a class attribute, and each attribute maps to a database column.
id field is added automatically.

Migrate Data Model to MongoDB database

Run the Python script: python makemigrations tutorials.

The console will show:

Migrations for 'tutorials':
	  - Create model Tutorial

New file has just been generated in tutorials/migrations folder. It includes code to create Tutorial data model:

# Generated by Django 2.1.15
  from django.db import migrations, models
  class Migration(migrations.Migration):
	  initial = True
	  dependencies = [
	  operations = [
				  ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
				  ('title', models.CharField(default='', max_length=70)),
				  ('description', models.CharField(default='', max_length=200)),
				  ('published', models.BooleanField(default=False)),

The generated code defines Migration class (subclass of the django.db.migrations.Migration).
It has operations array that contains operation for creating collection for Customer model: migrations.CreateModel().

The call to this will create a new model in the project history and a corresponding collection in the MongoDB database to match it.

Now run the following Python script to apply the generated migration above:
python migrate tutorials

The console will show:

Operations to perform:
	Apply all migrations: tutorials
  Running migrations:
	Applying tutorials.0001_initial... OK

Check MongoDB database, you can see that a collection for Tutorial model was generated automatically with the name: tutorials_tutorial:


Create Serializer class for Data Model

Let’s create TutorialSerializer class that will manage serialization and deserialization from JSON.

It inherit from rest_framework.serializers.ModelSerializer superclass which automatically populates a set of fields and default validators. We need to specify the model class here.


from rest_framework import serializers 
  from tutorials.models import Tutorial
  class TutorialSerializer(serializers.ModelSerializer):
	  class Meta:
		  model = Tutorial
		  fields = ('id',

In the inner class Meta, we declare 2 attributes:

  • model: the model for Serializer
  • fields: a tuple of field names to be included in the serialization

Define Routes to Views functions

Let determine how the server will response for HTTP request (GET, POST, PUT, DELETE) with some endpoints. We’re gonna define the routes:

  • /api/tutorials: GET, POST, DELETE
  • /api/tutorials/:id: GET, PUT, DELETE
  • /api/tutorials/published: GET

Inside tutorials app, create file with urlpatterns containing urls to be matched with the functions in the

from django.conf.urls import url 
  from tutorials import views 
  urlpatterns = [ 
	  url(r'^api/tutorials$', views.tutorial_list),
	  url(r'^api/tutorials/(?P<pk>[0-9]+)$', views.tutorial_detail),
	  url(r'^api/tutorials/published$', views.tutorial_list_published)

Don’t forget to include this URL patterns in root URL configurations.
Open DjangoRestApiMongoDB/ and modify the content with the following code:

from django.conf.urls import url, include 
  urlpatterns = [ 
	  url(r'^', include('tutorials.urls')),

Write API Views

Now we create the functions that are pointed in Url Patterns above:
tutorial_list(): GET list of tutorials, POST a new tutorial, DELETE all tutorials
tutorial_detail(): GET / PUT / DELETE tutorial by ‘id’
tutorial_list_published(): GET all published tutorials

These functions process HTTP requests and make CRUD Operations to database via Django Model.

Open tutorials/ and write following code:

from django.shortcuts import render
  from django.http.response import JsonResponse
  from rest_framework.parsers import JSONParser 
  from rest_framework import status
  from tutorials.models import Tutorial
  from tutorials.serializers import TutorialSerializer
  from rest_framework.decorators import api_view
  @api_view(['GET', 'POST', 'DELETE'])
  def tutorial_list(request):
	  # GET list of tutorials, POST a new tutorial, DELETE all tutorials
  @api_view(['GET', 'PUT', 'DELETE'])
  def tutorial_detail(request, pk):
	  # find tutorial by pk (id)
		  tutorial = Tutorial.objects.get(pk=pk) 
	  except Tutorial.DoesNotExist: 
		  return JsonResponse({'message': 'The tutorial does not exist'}, status=status.HTTP_404_NOT_FOUND) 
	  # GET / PUT / DELETE tutorial
  def tutorial_list_published(request):
	  # GET all published tutorials

Let’s implement these functions.

Create a new object

Create and Save a new Tutorial:

@api_view(['GET', 'POST', 'DELETE'])
  def tutorial_list(request):
	  elif request.method == 'POST':
		  tutorial_data = JSONParser().parse(request)
		  tutorial_serializer = TutorialSerializer(data=tutorial_data)
		  if tutorial_serializer.is_valid():
			  return JsonResponse(, status=status.HTTP_201_CREATED) 
		  return JsonResponse(tutorial_serializer.errors, status=status.HTTP_400_BAD_REQUEST)

Retrieve objects (with condition)

Retrieve all Tutorials/ find by title from MongoDB database:

@api_view(['GET', 'POST', 'DELETE'])
  def tutorial_list(request):
	  if request.method == 'GET':
		  tutorials = Tutorial.objects.all()
		  title = request.GET.get('title', None)
		  if title is not None:
			  tutorials = tutorials.filter(title__icontains=title)
		  tutorials_serializer = TutorialSerializer(tutorials, many=True)
		  return JsonResponse(, safe=False)
		  # 'safe=False' for objects serialization

Retrieve a single object

Find a single Tutorial with an id:

@api_view(['GET', 'PUT', 'DELETE'])
  def tutorial_detail(request, pk):
	  # ... tutorial = Tutorial.objects.get(pk=pk)
	  if request.method == 'GET': 
		  tutorial_serializer = TutorialSerializer(tutorial) 
		  return JsonResponse( 

Update an object

Update a Tutorial by the id in the request:

@api_view(['GET', 'PUT', 'DELETE'])
  def tutorial_detail(request, pk):
	  # ... tutorial = Tutorial.objects.get(pk=pk)
	  # ...
	  elif request.method == 'PUT': 
		  tutorial_data = JSONParser().parse(request) 
		  tutorial_serializer = TutorialSerializer(tutorial, data=tutorial_data) 
		  if tutorial_serializer.is_valid(): 
			  return JsonResponse( 
		  return JsonResponse(tutorial_serializer.errors, status=status.HTTP_400_BAD_REQUEST) 

Delete an object

Delete a Tutorial with the specified id:

@api_view(['GET', 'PUT', 'DELETE'])
  def tutorial_detail(request, pk):
	  # ... tutorial = Tutorial.objects.get(pk=pk)
	  # ...
	  elif request.method == 'DELETE': 
		  return JsonResponse({'message': 'Tutorial was deleted successfully!'}, status=status.HTTP_204_NO_CONTENT)

Delete all objects

Delete all Tutorials from the database:

@api_view(['GET', 'POST', 'DELETE'])
  def tutorial_list(request):
	  # ...
	  elif request.method == 'DELETE':
		  count = Tutorial.objects.all().delete()
		  return JsonResponse({'message': '{} Tutorials were deleted successfully!'.format(count[0])}, status=status.HTTP_204_NO_CONTENT)

Find all objects by condition

Find all Tutorials with published = True:

  def tutorial_list_published(request):
	  tutorials = Tutorial.objects.filter(published=True)
	  if request.method == 'GET': 
		  tutorials_serializer = TutorialSerializer(tutorials, many=True)
		  return JsonResponse(, safe=False)

Test the CRUD with APIs

Run our Django Project with command: python runserver 8080.
The console shows:

python runserver 8080
  Performing system checks...
  System check identified no issues (0 silenced).
  March 30, 2020 - 16:24:01
  Django version 2.1.15, using settings 'DjangoRestApiMongoDB.settings'
  Starting development server at
  Quit the server with CTRL-BREAK.

Using Postman, we’re gonna test all the Apis above.

  1. Create a new Tutorial using POST /tutorials Api

  2. django-mongodb-crud-rest-api-example-create

    Check MongoDB database after creating some Tutorials:


  3. Retrieve all Tutorials using GET /tutorials Api

  4. django-mongodb-crud-rest-api-example-retrieve

  5. Retrieve a single Tutorial by id using GET /tutorials/:id Api

  6. django-mongodb-crud-rest-api-example-retrieve-one

  7. Update a Tutorial using PUT /tutorials/:id Api

  8. django-mongodb-crud-rest-api-example-update

    Check tutorials_tutorial collection after some rows were updated:


  9. Find all Tutorials which title contains ‘ngo’: GET /tutorials?title=ngo

  10. django-mongodb-crud-rest-api-example-find-by-field

  11. Find all published Tutorials using GET /tutorials/published Api

  12. django-mongodb-crud-rest-api-example-find-by-active

  13. Delete a Tutorial using DELETE /tutorials/:id Api

  14. django-mongodb-crud-rest-api-example-delete-one

    Tutorial with id=4 was removed from tutorials_tutorial collection:


  15. Delete all Tutorials using DELETE /tutorials Api

  16. django-mongodb-crud-rest-api-example-delete


Today, we’ve learned how to create MongoDB & Django Rest Framework for Rest Apis CRUD example. We also know way to connect Django application with MongoDB database, create a Django Model, migrate it to database, write the Views and define Url patterns for handling all CRUD operations.

Happy learning! See you again.

Further Reading

Source code

You can find the complete source code for this example on Github.

More articles you would like to check: