YAML, XML, JSON Response Renderer in Django Rest Framework

In Django Rest Framework (DRF), the ability to generate responses in different formats, such as YAML, XML, and JSON, plays a pivotal role in creating versatile APIs. These response renderers allow you to tailor your API outputs to match varying client preferences. In this comprehensive blog post, we’ll explore the YAMLRenderer, XMLRenderer, and JSONRenderer in DRF, accompanied by practical examples.

Content negotiation in the context of web APIs refers to the process of selecting the appropriate representation of a resource (such as JSON, XML, HTML, etc.) to be returned by the server based on the client’s preferences and capabilities. It allows clients and servers to communicate about the desired format of the data being exchanged.

Learn More about Custom Response Content Negotiation in Django Rest Framework.

Understanding DRF Response Renderers

1. YAMLRenderer: The YAMLRenderer in DRF transforms response data into the YAML (YAML Ain’t Markup Language) format. YAML’s human-readable syntax is particularly useful for configuration files and structured data.

2. XMLRenderer: The XMLRenderer renders response data in the XML (eXtensible Markup Language) format. XML is commonly used for data interchange between systems.

3. JSONRenderer: The JSONRenderer is the default renderer in DRF. It converts response data into the JSON (JavaScript Object Notation) format, which is widely used for web APIs due to its simplicity and compatibility with various programming languages.

Examples for Response Rendering

For this tutorial, we are using our basic skeleton project for Django.

Step 1: Install Required Packages

  1. Open your terminal.
  2. Run the following commands to install the necessary packages:
   pip install djangorestframework
   pip install djangorestframework-yaml
   pip install djangorestframework-xml

Step 2: Configure Your DRF Settings

  1. In your project’s settings.py file, configure the renderer classes for each format:
           # ... other renderer classes ...


# views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework_yaml.renderers import YAMLRenderer

class YAMLView(APIView):
    renderer_classes = [YAMLRenderer]

    def get(self, request):
        data = {'message': 'This response is in YAML format!'}
        return Response(data)

2. XMLRenderer:

# views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework_xml.renderers import XMLRenderer

class XMLView(APIView):
    renderer_classes = [XMLRenderer]

    def get(self, request):
        data = {'message': 'This response is in XML format!'}
        return Response(data)

3. JSONRenderer (Default):

# views.py
from rest_framework.views import APIView
from rest_framework.response import Response

class JSONView(APIView):

    def get(self, request):
        data = {'message': 'This response is in JSON format!'}
        return Response(data)

Configuring URLs:

# urls.py
from django.urls import path
from .views import YAMLView, XMLView, JSONView

urlpatterns = [
    path('yaml/', YAMLView.as_view(), name='yaml-view'),
    path('xml/', XMLView.as_view(), name='xml-view'),
    path('json/', JSONView.as_view(), name='json-view'),

Testing the Renderers Based on Different Content Type Response:

  1. Run your Django server.
  2. Access the URLs http://localhost:8000/yaml/, http://localhost:8000/xml/, and http://localhost:8000/json/ in your browser or API client.
  3. Set the Accept header to application/yaml, application/xml, or application/json respectively to receive responses in the desired format.

Certainly! Here are the cURL commands you can use to test each renderer for the respective views:

1. YAMLRenderer (YAML format):

curl -H "Accept: application/yaml" http://localhost:8000/yaml/

2. XMLRenderer (XML format):

curl -H "Accept: application/xml" http://localhost:8000/xml/

3. JSONRenderer (JSON format):

curl -H "Accept: application/json" http://localhost:8000/json/

These commands send requests to the specified URLs with the respective Accept headers, allowing you to receive responses in the desired format. Make sure your Django development server is running and replace http://localhost:8000 with the appropriate URL if you’re using a different configuration.


By embracing the capabilities of YAMLRenderer, XMLRenderer, and JSONRenderer in Django Rest Framework, you’re equipped to provide tailored API responses in different formats. This flexibility facilitates seamless communication between your API and its consumers, ensuring optimal user experiences across various platforms. By understanding, configuring, and harnessing these renderers effectively, you’re well on your way to becoming a master of response rendering in DRF.

Find this project on Github.

Blogs You Might Like to Read!