Forem: Prabodh Tuladhar

Introduction to serializers in Django Rest Framework (DRF) Part II

Prabodh Tuladhar — Thu, 05 Feb 2026 07:14:31 +0000

In Part I of the tutorial, we built serializers from scratch.

We defined a ProductModel with the fields name, description, price, stock, is_active. We then typed every single one of these fields again when we defined the ProductSerializer.

Repetitive Code in ProductModel and ProductSerializer

Enter ModelSerializer.

In this article, we are going to take the code we wrote in Part I and use ModelSerializer to reduce the repetitive code.

What is a `ModelSerializer`?

A ModelSerializer is a shortcut that automatically creates a serializers class with fields that are in the model class.

When we use a ModelSerializer, DRF inspects the model and automatically does these things:

Generates fields from the model so you don't have to
Automatically adds field validations. Your model may have rules such as unique=True, ModelSerializer reads these rules and implements them automatically
Implements create() and update() methods. A ModelSerializer knows which model to use and how to update and create it. You can override create() and update() methods if you need customized behaviors.

Let's look at the ProductModel we created in Part I

# demo/models.py

from django.db import models

class ProductModel(models.Model):
    name = models.CharField(max_length=150)
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)
    stock = models.IntegerField()
    is_active = models.BooleanField(default=True)

    def __str__(self):
        return self.name

and here was the ProductSerializer associated with the model

#demo/serializers.py

from rest_framework import serializers
from .models import ProductModel

class ProductSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=150)
    description = serializers.CharField()
    price = serializers.DecimalField(max_digits=10, decimal_places=2)
    stock = serializers.IntegerField()
    is_active = serializers.BooleanField()

    # We must implement this to support saving data
    def create(self, validated_data):
        # We unpack the validated data and create a model instance
        return ProductModel.objects.create(**validated_data)

Now lets rewrite the above code using ModelSerializer.

The updated code should look something like this

#demo/serializers.py

from rest_framework import serializers
from .models import ProductModel

class ProductSerializer(serializers.ModelSerializer):
    class Meta:
        model = ProductModel
        fields = ['name', 'description', 'price', 'stock', 'is_active']

Now lets take a look at what we changed. The first change is the ProductSerializer class inherits from serializer.ModelSerializer instead of the base serializer class.

Another important difference is the lack of fields corresponding to ProductModel, instead we have given the name of the model and ModelSerializer automatically generates the fields based on this model. Also we have specified which fields to generate in the fields attribute

ProductSerializer inherits from ModelSerializer

But wait, we have written the models and fields inside another class called Meta. Let's also be talk about this class.

Meta class is an inner class since we have defined the class inside a pre existing class.

models and fields attributes defined inside class Meta

Think of the Meta class as Configuration Settings for the serializer.

In the regular serializer, we built all the fields by ourselves so we did not need this inner class, but for the ModelSerializer we are asking DRF to build all the fields for us, so it needs to know from which model to build the field and what to include in the fields.

We write all of these configurations in the Meta class.

If we forget to write the Meta class and only specify the models and fields, Python will throw an AssertionError.

We can also replace the list of fields with __all__, though writing all the fields explicitly is a better practice.

#demo/serializers.py

from rest_framework import serializers
from .models import ProductModel

class ProductSerializer(serializers.ModelSerializer):
    class Meta:
        model = ProductModel
        # fields = ['name', 'description', 'price', 'stock', 'is_active']
        # we can write __all__ instead of typing name of all the fields
        fields = '__all__'

Now lets open up the python shell to see if this works or not. Make sure your python virtual environment where you have installed Django and Django Rest Framework is active.

python manage.py shell

First lets import our models and serializers

from demo.models import ProductModel
from demo.serializers import ProductSerializer

Step 1: Create a dummy data

product = ProductModel.objects.create(
    name='Asus Zenbook 14',
    description='Asus ZenBook 14 I7 11th Gen | 16GB RAM | 512GB SSD',
    price=110.99, 
    stock=72, 
    is_active=True
)

Step 2: Serialize the data

Now we pass the object to the serializer and print the serializer

serializer = ProductSerializer(product)
print(serializer.data)

When we print this we get the following output

Output:

{
    'id': 1,
    'name': 'Asus Zenbook 14',
    'description': 'Asus ZenBook 14 I7 11th Gen | 16GB RAM | 512GB SSD',
    'price': 110.99,
    'stock': 72,
    'is_active': True
}

Step 3: Deserialize the data

Now lets deserialize the data as well. Imagine as before, a user has added another product. This data is represented as JSON and we must save this data to the database.

Lets assume this is the incoming data

{
    "name": "Dell XPS 13",
    "description": "Dell XPS 13 I7 12th Gen | 16GB RAM | 1TB SSD",
    "price": 1499.99,
    "stock": 45,
    "is_active": True
}

Step 4: Save the data

Now lets deserialize the data and save it to the database

data = {
    "name": "Dell XPS 13",
    "description": "Dell XPS 13 I7 12th Gen | 16GB RAM | 1TB SSD",
    "price": 1499.99,
    "stock": 45,
    "is_active": True
}
serializer = ProductSerializer(data=data)

As before we will print the data after checking the validity of the data using the is_valid() method

if serializer.is_valid():
    print(serializer.data)
else:
    print(serializer.errors)

We get the following output.
Output:

{
    'name': 'Dell XPS 13',
    'description': 'Dell XPS 13 I7 12th Gen | 16GB RAM | 1TB SSD',
    'price': '1499.99',
    'stock': 45,
    'is_active': True
}

This code has deserialized the data and to save this deserialized data we use the use the serializer.save() method

if serializer.is_valid():
    print(serializer.data)
    # save the deserialized data
    serializer.save()

else:
    print(serializer.errors)

We can see that this data has been saved in the database by running this query.

stored_data = ProductModel.objects.filter(name='Dell XPS 13')
print(stored_data)

This code gives the following output:

Output:

<QuerySet [<ProductModel: Dell XPS 13>]>

Here we need to understand another important fact about ModelSerializer. Previously in our base Serializer, we had to implement the create() method ourselves but in the ModelSerializer the create() method has already been implemented.

This allows us to call the save() method. In addition to automatic implementation of create() method, ModelSerializer also automatically implements update() method.

Peeking Under the Hood

1. Checking the fields

We have seen that ModelSerializer has automatically generated the serializers fields and automatically generated the create() and update() method.

We can actually ask Python to show you what code DRF generated for you. In your shell, type:

print(repr(serializer))

This gives output:

Output:

We can see that DRF has automatically created all these fields automatically based on our model.

In this two-part series, I have tried to demystify the Django Serializer.

Part I showed us that serializers are just translators between Python Objects and JSON.
Part II showed us how ModelSerializer automates the boring parts of that translation.

Now that you have your data serialized, the next step is to figure out how to send it to the user through URLs and Views. But that is a story for another article.

We have covered a lot of ground in this two-part series.

In Part I, we dismantled the concept of serialization, built classes manually, and wrote our own validation logic. This was crucial for understanding how DRF works under the hood.
In Part II, we leveraged the power of ModelSerializer to eliminate boilerplate: We deleted 90% of our code while keeping the same and automate logic creation to some extent.

So, which one of the serializers should you use?

As a rule of thumb:

Stick to ModelSerializer for standard resources (like Users, Products, Orders) where your API mirrors your database. This will be 95% of your work.
Keep the base Serializer in your back pocket for non-database actions, such as handling a Login request, validating a contact form, or processing a file upload that goes to AWS S3 instead of your database.

References

Serializers - Django Rest Framework
Serializer Tutorial - Django Rest Framework

Introduction to serializers in Django Rest Framework (DRF) Part I

Prabodh Tuladhar — Tue, 03 Feb 2026 07:48:32 +0000

👉 This is a two part series. You can find Part II here.

If you are new to Django REST Framework (DRF), one concept that often confuses beginners is Serializers.

In this article, I’ll break it down in simple terms, show you how to build one from scratch, and explain why they are the most critical part of your API.

What is a Serializer?

In DRF, a serializer is like a bridge between your database and the internet.

Django models store data as Python objects. However, when you want to send that data to a frontend application (like React or a mobile app), you cannot send Python objects. You need to send a format that everyone understands which is usually JSON.

Serializers perform three main jobs:

Serialization: Converting complex Python objects (Models) into Python dictionaries (which can be easily rendered into JSON).
Deserialization: Converting JSON data coming from a user back into complex Python objects.
Validation: Checking if the incoming data is correct before saving it to the database.

Why Do We Need Them?

In a standard Django application, we interact with data using Models. Let's look at a simple scenario. We want to build a store, so we define a ProductModel.

(Create this in your models.py file)

# demo/models.py

from django.db import models

class ProductModel(models.Model):
    name = models.CharField(max_length=150)
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)
    stock = models.IntegerField()
    is_active = models.BooleanField(default=True)

    def __str__(self):
        return self.name

If you try to send a ProductModel instance directly to a web browser, it will crash. The browser doesn't speak "Python Class"; it speaks "JSON".

We need a translator. That translator is the Serializer.

Creating Your First Serializer

There are several types of serializers in DRF, such as ModelSerializer, HyperLinkedSerializer, and ListSerializer. To truly understand how they work, we are going to start with the base Serializer class.

We will create a serializers.py file in our app (let's call the app demo) and define a serializer that mirrors our model.

# demo/serializers.py
from rest_framework import serializers 

class ProductSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=150)
    description = serializers.CharField()
    price = serializers.DecimalField(max_digits=10, decimal_places=2)
    stock = serializers.IntegerField()
    is_active = serializers.BooleanField()

Notice that we had to repeat the fields from the Model. We will solve this redundancy in Part 2, but for now, this explicit style helps us understand exactly what is happening.

Seeing Serialization in Action

The best way to learn DRF is not through the web browser, but through the Python Shell. This allows us to see the data transformation step-by-step.

Open your terminal and run. Make sure your python virtual environment where you have installed Django and Django Rest Framework is active.

python manage.py shell

First, let's import our model and serializer.

from demo.models import ProductModel
from demo.serializers import ProductSerializer

Step 1: Create Dummy Data

Let's create a product in our database using standard Django code.

product = ProductModel.objects.create(
    name='Logitech MX Master',
    description='Ergonomic Logitech Mouse', 
    price=110.99, 
    stock=72, 
    is_active=True
)

Step 2: Serialize the Data

Now, we pass this product object into our serializer.

serializer = ProductSerializer(product)

To see the translated data, we access the .data attribute.

print(serializer.data)

Output:

{
   'name': 'Logitech MX Master',
   'description': 'Ergonomic Logitech Mouse',
   'price': '110.99',
   'stock': 72,
   'is_active': True
}

Success! The serializer took a Python Object and converted it into a Python Dictionary. This dictionary can now be easily turned into JSON and sent over the API.

Deserialization (The Reverse Process)

Now, let's look at the reverse scenario. A user wants to create a new product via your API. They will send you a JSON object.

Let's assume this is the incoming data:

data = {
    "name": "Mechanical Keyboard",
    "description": "Backlit mechanical keyboard",
    "price": "24.99",
    "stock": 10,
    "is_active": True
}

To convert this raw data back into a Python object, we pass it to the serializer using the data argument:

serializer = ProductSerializer(data=data)

A common mistake beginners make is trying to access the data immediately.

# DO NOT DO THIS
print(serializer.data)

Output:

AssertionError: When a serializer is passed a `data` keyword argument you must call `.is_valid()` before attempting to access the serialized `.data` representation.

DRF protects your database. It refuses to let you touch the data until you confirm it is valid. You must call is_valid() first. If the is_valid() method is not called, Python will throw an AssertionError

if serializer.is_valid():
    print(serializer.validated_data)
else:
    print(serializer.errors)

Since our data matches the requirements (e.g., price is a decimal, stock is an integer, is_active is boolean), it returns True.

Saving the Data

Now that the data is valid, we want to save it to the database. Usually, you would call serializer.save().

However, if you try to run serializer.save() right now, it will fail.

Why? Because the base Serializer class doesn't know how to create a ProductModel. We have to tell it how.

Let's go back to serializers.py and implement the create() method.

class ProductSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=150)
    description = serializers.CharField()
    price = serializers.DecimalField(max_digits=10, decimal_places=2)
    stock = serializers.IntegerField()
    is_active = serializers.BooleanField()

    # We must implement this to support saving data
    def create(self, validated_data):
        # We unpack the validated data and create a model instance
        return ProductModel.objects.create(**validated_data)

Now, back in your shell, if you run:

serializer.save()

It will successfully create the "Mechanical Keyboard" in your database.

Wrap Up

We have successfully built a serializer that can:

Read a Django Model and convert it to a dictionary (Read).
Take a dictionary, validate it, and convert it into a Django Model (Write).

But did you notice something annoying?

We repeated a lot of code. We typed name, price, and stock in the Model, and then we typed them again in the Serializer. In a real project with dozens of models, this violates the DRY (Don't Repeat Yourself) principle.

In Part 2, I will introduce the ModelSerializer, a powerful shortcut that writes all this boilerplate code for you automatically.

Forem: Prabodh Tuladhar

Introduction to serializers in Django Rest Framework (DRF) Part II

What is a ModelSerializer?

Step 1: Create a dummy data

Step 2: Serialize the data

Step 3: Deserialize the data

Step 4: Save the data

Peeking Under the Hood

References

Introduction to serializers in Django Rest Framework (DRF) Part I

What is a Serializer?

Why Do We Need Them?

Creating Your First Serializer

Seeing Serialization in Action

Step 1: Create Dummy Data

Step 2: Serialize the Data

Deserialization (The Reverse Process)

Saving the Data

Wrap Up

References

What is a `ModelSerializer`?