In many real-world applications, you may not always want to return all fields in a serializer. You might want to:

• Return a subset of fields based on user role.

• Return different fields based on context (like a list vs detail view).

• Let the client specify which fields they want.

This is where Dynamic Fields in Django REST Framework serializers come into play.

What Are Dynamic Fields?

Dynamic fields allow you to dynamically control which fields appear in the serialized output at runtime. Instead of defining all fields statically, you write logic that includes or excludes fields as needed.

Basic Example: Accept a fields Query Param

Let’s say you have a BookSerializer:

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'description', 'published']

You want clients to specify the fields they need:

GET /api/books/1/?fields=id,title

✅ Create a Dynamic Fields Serializer Mixin

class DynamicFieldsModelSerializer(serializers.ModelSerializer):
    def __init__(self, *args, **kwargs):
        fields = kwargs.pop('fields', None)
        super().__init__(*args, **kwargs)

        if fields is not None:
            allowed = set(fields)
            existing = set(self.fields)
            for field_name in existing - allowed:
                self.fields.pop(field_name)

Use It in Your Serializer

class BookSerializer(DynamicFieldsModelSerializer):
    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'description', 'published']

In Your View

class BookDetailView(generics.RetrieveAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    def get_serializer(self, *args, **kwargs):
        fields = self.request.query_params.get('fields')
        if fields:
            kwargs['fields'] = fields.split(',')
        return super().get_serializer(*args, **kwargs)

Now your API supports field selection via query parameters.

Use Case: Role-Based Fields

Return certain fields only for admin users.

class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['id', 'email', 'is_staff', 'is_active']

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        request = self.context.get('request')
        if request and not request.user.is_staff:
            self.fields.pop('is_staff')

Use Case: List vs Detail Views

class ProductSerializer(serializers.ModelSerializer):
    class Meta:
        model = Product
        fields = ['id', 'name', 'description', 'price', 'inventory']

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        view = self.context.get('view')
        if view and hasattr(view, 'action') and view.action == 'list':
            self.fields.pop('inventory')

This will hide inventory in list views but show it in detail views.

Tips for Using Dynamic Fields

⚠️ Common Pitfalls

Full Example: Dynamic Fields Based on User Role

models.py

class Employee(models.Model):
    name = models.CharField(max_length=100)
    salary = models.DecimalField(max_digits=10, decimal_places=2)
    department = models.CharField(max_length=50)

serializers.py

class EmployeeSerializer(serializers.ModelSerializer):
    class Meta:
        model = Employee
        fields = ['name', 'salary', 'department']

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        request = self.context.get('request')

        # Hide salary for non-admins
        if request and not request.user.is_staff:
            self.fields.pop('salary')

Output for Regular User

{
  "name": "John Doe",
  "department": "HR"
}

Output for Admin

{
  "name": "John Doe",
  "salary": "50000.00",
  "department": "HR"
}

When to Use vs Avoid Dynamic Fields

✅ Summary

Conclusion

Dynamic fields in serializers give your API the flexibility to serve different data views to different users or use cases — all while using the same serializer class. When used wisely, they reduce redundancy and improve user experience.