Django Rest Framework with PostgreSQL: A CRUD Tutorial

Figure showing Django REST Framework and PostgreSQL logos

Working with APIs is important for most web developers. From extending other services for your app to providing resources for other apps and services, APIs are essential to modern web systems for application-to-application communication.

API, an acronym for Application Programming Interface is a means by which the client-side interacts with the server-side to respond to the request of the user. It is a protocol that establishes how components of software communicate together.

In this tutorial, we shall go through the procedure of creating a REST API with Django and a PostgreSQL database for a customer management app. We shall set up a Django app with Django Rest Framework. Also, we will install PostgreSQL and connect it with our API. Besides, we shall perform CRUD operations (GET, POST, PUT and DELETE) on the API.

The objective of this tutorial is to create a RESTful API with CRUD capabilities on the database. We shall set up the Django REST framework, create the views and corresponding URL patterns for the APIs and

In detail, we shall answer some questions and discuss some concepts which are the following:

  • What is Django?


To be able to follow this tutorial, you need to:

  • Have Python and pip package manager installed

What is Django?

Django is an open-source Python framework for building high-performance web applications. It works by the Model-View-Controller design. A notable benefit of the framework is that it enables you to build websites with speed without re-inventing the wheel.

What is a REST API?

RESTful API is an architectural standard for APIs that request data using HTTP. The data can be used to create, update, read, and delete resources. REST is an acronym for representational state transfer and, it uses HTTP to request data from a particular URL and, it returns the data in different formats such as JSON, HTML, etc.

What is Django Rest Framework

Django REST framework (DRF) is an extensive and versatile toolkit for building APIs for the web. Not only is it widely used, but it is also very customizable.

What are CRUD operations?

CRUD refers to the four basic operations — Create, Read, Update and Delete — used in relational database systems.

CRUD enables the basic functionalities of creating, reading, updating, and deleting resources in a REST environment. The CRUD operations are usually mapped to standard HTTP methods — POST for creating, GET for reading, PUT for updating, and DELETE for deleting respectively.

From a database management perspective, the following explains how the CRUD operations work.

  • CREATE: INSERT to create a new database record

What is PostgreSQL?

PostgreSQL is a free and open-source relational database system. It provides the developer with extensibility and scalability. It works with a lot of programming languages and all major operating systems such as Windows, macOS, and Linux. We will use PostgreSQL as our database for the CRUD app we will build.

Installing PostgreSQL

You can install PostgreSQL with the following command in the terminal.

sudo apt-get update
sudo apt-get install python-pip python-dev libpq-dev postgresql postgresql-contrib

On macOS, you can install posgresql in the terminal with brew:

brew install postgresql

Now, you may start postresql after its installation with the following command.

brew services start postgresql

If you use a Windows machine, you can download a compatible PostgreSQL installer from the official website of PostgreSQL.

Creating a Database

As part of the installation, PostgreSQL already created a user, postgres by default for carrying out administrative responsibilities. We shall change to the user to create our database and new user.

sudo su - postgres

psql gives us access to the Postgres interactive terminal where we can use the PostgreSQL queries.


Now, we shall create a database for this project. Always make sure to create a separate database for each project you work on.


In the above command, we have used the CREATE command in SQL to create our database which we named mydb. We also ended the line with a semi-colon which comes after every command in SQL.

Creating a Database User

Now, we shall create a database user for our database. We will call the user myuser. Replace password with a strong password below.

CREATE USER myuser WITH PASSWORD 'password';

Let us now grant access rights to our new user to enable it to work on the database.


We can then exit the current user’s shell session and get back to the postgres user's session


Now, let us leave the PostgreSQL interactive terminal back to the terminal.


Installing Django and Setting up a Django Project

When working with Django apps, always create new Django projects in isolated environments with virtual environment packages like virtualenv. Virtual environments help us to work with different versions of Python and other packages with different projects we have on our machine. Let us get the virtualenv package which we shall use to create our virtual environment

sudo pip install virtualenv

Then, let us create a folder to house our projects and change directory into the new folder.

mkdir myproject && cd myproject

Inside the new folder, we will create the virtual environment for our project.

virtualenv env

The above command provides us a duplicate of Python and some other libraries in an isolated environment.

We will activate the virtual environment so we can use it in our project.

source env/bin/activate

The terminal should look like below. The name of the virtual environment will be in brackets preceding the line to show that the virtual environment has been activated.

(env) user@host:_

Going forward, we will install Django and set up our Django app inside the virtual environment.

pip install django djangorestframework psycopg2

We installed the following packages:

  • Django: the Django package that allows us to work with the Django framework and create Django apps

Now, we shall create a Django project with the django-admin command.

django-admin startproject crm_project

cd into the crm-project directory and cd into the sub-directory, crm-project. We need to add the rest_framework into the file so it will be active in our project. Let us add it inside the INSTALLED_APPS list:

'rest_framework', #new

Setting up Django Database Configuration

We have created a PostgreSQL database and a Django project. Now, we shall configure our Django project to use the PostgreSQL database.

Inside the file of the project, you will see the DATABASES section. It looks like the following:

'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),

We need to change the SQLite database configuration to the PostgreSQL database that we created. Therefore, replace the DATABASES code with the following:

'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'myproject',
'USER': 'myuser',
'PASSWORD': 'password',
'HOST': 'localhost',
'PORT': '',

Creating a Django app

Let us create an app in our Django project using file in the root directory of the project. It allows us to work with Django in various ways such as creating apps, creating database tables from models, running the inbuilt server, etc. Whenever you want to run the file, ensure that you are at the root directory where exists,

python startapp customer

If you check the directory, a new sub-directory, customer has been created. Let us add the new customer app to the INSTALLED_APPS list in the file of our crm-project.

'customer', #new

If you cd into the customer directory, you would see that it has its and files.

We shall create models for the customer app. Open the file of the customer app, replace the content in it with the following code.

from django.db import models

class Customer(models.Model):
name = models.CharField("Name", max_length=240)
email = models.EmailField()
created = models.DateField(auto_now_add=True)

def __str__(self):

The Customer class in the above code extends from Django's Model class. CharField, EmailField , and DateField are appropriate data types for the respective fields.

At this point, we will create database columns with the fields of our models through the process of migration. We will use the file to apply the migrations.

python makemigrations


python migrate

Creating a REST API with Django Rest Framework

We shall build our API on Django Rest Framework. We shall be dealing with views, serializers, and URL endpoints. The endpoints are attached to the views which fetch the responses to web requests.

Serializers help with translating between JSON, XML, and native Python objects. Create a new file in the customer directory and name it Input the following code into it.

from rest_framework import serializers
from .models import Customer

class CustomerSerializer(serializers.ModelSerializer):

class Meta:
model = Customer
fields = ['pk', 'name', 'email', 'created']

The ModelSerializer in the code above helps to serialize data for Customer objects.

Now, we shall extend the GenericAPIViews that comes shipped with Django Rest Framework to create our views. Add the following code inside the file of the customer app.

from django.shortcuts import render
from .models import Customer
from rest_framework import generics
from .serializers import CustomerSerializer

class CustomerCreate(generics.CreateAPIView):
# API endpoint that allows creation of a new customer
queryset = Customer.objects.all(),
serializer_class = CustomerSerializer

class CustomerList(generics.ListAPIView):
# API endpoint that allows customer to be viewed.
queryset = Customer.objects.all()
serializer_class = CustomerSerializer

The above code enables us to use the CustomerCreate view to create a new customer object, and the CustomerList view will be used to list all the customers in the database.

Should in case we want to check for a single customer, we can add a CustomerDetail view as follows:

class CustomerDetail(generics.RetrieveAPIView):
# API endpoint that returns a single customer by pk.
queryset = Customer.objects.all()
serializer_class = CustomerSerializer

We will include a view for the Update action,

class CustomerUpdate(generics.RetrieveUpdateAPIView):
# API endpoint that allows a customer record to be updated.
queryset = Customer.objects.all()
serializer_class = CustomerSerializer

Let us add a view for the DELETE operation,

class CustomerDelete(generics.RetrieveDestroyAPIView):
# API endpoint that allows a customer record to be deleted.
queryset = Customer.objects.all()
serializer_class = CustomerSerializer

Now, create a new file in the customer directory and add the following code to it.

from django.urls import include, path
from .views import CustomerCreate, CustomerList, CustomerDetail, CustomerUpdate, CustomerDelete

urlpatterns = [
path('create/', CustomerCreate.as_view(), name='create-customer'),
path('', CustomerList.as_view()),
path('<int:pk>/', CustomerDetail.as_view(), name='retrieve-customer'),
path('update/<int:pk>/', CustomerUpdate.as_view(), name='update-customer'),
# path('delete/<int:pk>/', CustomerDelete.as_view(), name='delete-customer')

Each of the endpoints handles a particular HTTP method. The first endpoint handles the POST method for CREATE operation. The second and third endpoints handle the GET method for READ operations. The fourth endpoint handles the PUT method for UPDATE operation while the last endpoint handles the DELETE operation.

Notwithstanding, we still need to point the root file to the file of the customer app. Let us go back to the crm_project sub-directory and open the file there. We will then include the customer app endpoints.

from django.contrib import admin
from django.urls import path, include #new

urlpatterns = [
path('customer/', include('customer.urls')), #new

The file already contained the urlpattern for the Django-admin app which gives us administrator capabilities.

Django ships with an inbuilt server that could be used for testing purposes. We will run our application now through the server with the following command:

python runserver

Let us go to the URL on the browser and we shall the interface of the Browsable API. Browsable API comes with REST Framework and allows us to interact with our API in the absence of a client-side app. We can visit each of the routes earlier defined in the urlpatterns of our customer app and perform the CRUD operations.

The Browsable API looks like the following for the customer-create endpoint at


Well-done! We have learned how to set up a Rest API with Django connected to a PostgreSQL database. You can get the full code of the tutorial project here.

This tutorial helped us to build a RESTful API with the Django REST framework. We also learned how to set up PostgreSQL for a Django project. We used the command-line to create PostgreSQL databases and users. We connected the PostgreSQL database to a basic Django customer management application and added CRUD functionalities to the API.

With what we have learned, we should be able to create APIs in our web projects. We would also be able to learn more about API development. Thanks for your time. Kindly ask questions and share your ideas and suggestions.

Twitter | LinkedIn

Software | Aerospace Undergrad • ex-Lead @GoogleDevs’ DSC KWASU

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store