3 Steps To Developing A Successful Django File Upload

Developing a Django file upload solution is essential if you must run a form processing operation on your web application. The possibility of this operation enables your user to upload and submit files to the web servers.

With Django file upload successfully implemented on your web applications, the uploaded files can be retrieved, processed, stored, etc.

In this post, we’ll see what Django is all about and how to execute a Django file upload process.

Now, let’s get started with…

What is Django?

Django (https://www.djangoproject.com/) is a free, high-level Python framework used mainly for rapid web development. The framework was built by a team of experienced developers and it offers a clean, pragmatic design. Django is open source which means you can avoid reinventing the wheel, reduce web development hassles and only focus on writing your app. There are a bunch of positives we could go on and on about with Django.

But one advantage that has always stood for most developers is how ridiculously FAST the framework is. Django was built with SPEED in mind, helping you take web applications from concept to completion in little time. For most developers, security is a big deal and Django has this on lock. The framework does not compromise on security and will help you avoid many common security mistakes. Also, some of the largest and busiest sites/web applications online (including Spotify, Instagram, Quora, and YouTube) run on Django. This is a testament to its flexibility and scalability.

With that said about Django, let’s take a look at…

How To Implement a Successful Django File Upload?

File upload and processing is an essential operation of every web application.

Why is it important?

At some point, every web application will need to collect some data or information from the users. This could be files like images, videos, or documents.

And these end-users deserve a file upload experience that’s fast, and seamless, even on slow networks.

The Django file upload process allows for files to be uploaded, processed, stored, and retrieved.

When an operation to upload is initiated by the user, the file is tagged to the request through the request.Files[] section.

The request.Files capture the file details during the upload and keep them tagged within it.

Then, the uploaded file details and content need to be retrieved from this request.Files[] section and further processed by mentioning the request.FILES regarding the file name.

Doing this will create an object which acts more like a file-based object in the setup and storage process. All file details and content could now be pulled from this file-based object.

You just read the summary of the entire process.

Now, let’s take a deep dive and see the steps in detail to implement a successful Django file upload.

Step 1: How do I create a form file (forms.py)?

To get started with the file upload in Django, you need to create a form containing a FileField class.

Or you can simply insert the code below.

from django import forms

class UploadFileForm(forms.Form):
    title = forms.CharField(max_length=50)
    file = forms.FileField()

Step 2: How do I create View functions to handle the form (view.py)?

Next, you need to create a view function (view.py) to handle the form and receive the file data in request.FILES.

The view function is a Python function taking an HttpRequest from the HTML file and returns an HttpResponse with the values of the variables specified and requested by the HTML file.

It is essential to the entire Django file upload process as it is responsible for rendering and processing the file.

request.FILES is a dictionary containing a key for each FileField (or ImageField, or other FileField subclasses) in the form.

You can access the data from the form as request.FILES[‘file’].

Also, you should be aware request.FILES will only contain data if:

  •  the POST request method was used
  • one file field was posted, at least
  • and the <form> that posted the request has the attribute enctype=”multipart/form-data”

If any of these options is negative, request.FILES will not contain any data.

The Django code that you need to add to your views.py file should look like this:


from django.http import HttpResponseRedirect
from django.shortcuts import render from .forms import UploadFileForm

# Imaginary function to handle an uploaded file. from somewhere import handle_uploaded_file

def upload_file(request):
    if request.method == 'POST':
        form = UploadFileForm(request.POST, request.FILES)
        if form.is_valid():

            return HttpResponseRedirect('/success/url/')
         form = UploadFileForm()
     return render(request, 'upload.html', {'form': form})

Note that request.FILES was passed into the form’s constructor to ensure file data gets bound into a form.

Step 3: How do I set handling for Uploaded File?

Here’s a common way you might handle an uploaded file:


def handle_uploaded_file(f):
    with open('some/file/name.txt', 'wb+') as destination:
        for chunk in f.chunks():

To ensure that large files don’t clog your system’s memory, loop over UploadedFile.chunks() instead of using read().

For UploadedFile objects, there are some other methods and attributes available

  • UploadedFile.name — to display the name of the uploaded file.
  • UploadedFile.size — to display the size of the uploaded file.
  • UploadedFile.content_type — to state the content type that’s handled by the file.
  • UploadedFile.content_type_extra — to state the additional headers related to the content type.
  • UploadedFile.charset — to state the character set supplied by the browser
  • And more

What if you’re uploading multiple files?

If you want your user to upload more than a single file at a time using one form field, use this code in the multiple HTML attribute of the field’s widget:

forms.py¶ from django import forms


class FileFieldForm(forms.Form):
    file_field = forms.FileField(widget=forms.ClearableFileInput(attrs={'multiple': True}))

Next, override the post method of your FormView subclass to handle multiple file uploads.

You can use the code below.

views.py¶ from django.views.generic.edit import FormView from .forms import FileFieldForm

class FileFieldFormView(FormView):
    form_class = FileFieldForm
    template_name = 'upload.html' # Replace with your template.
    success_url = '...' # Replace with your URL or reverse().

    def post(self, request, *args, **kwargs):
        form_class = self.get_form_class()
        form = self.get_form(form_class)
        files = request.FILES.getlist('file_field')
        if form.is_valid():
            for f in files:
                ... # Do something with each file.
            return self.form_valid(form)
            return self.form_invalid(form)

That’s it.

Want to start building powerful file upload solutions using Filestack?

Around 1 in 10 file uploads fail — and I’m sure you don’t want your file upload to fail.

Filestack is a solution that helps you improve your file upload performance.

It offers a robust set of tools and powerful APIs to upload, transform and deliver content on the web easily.

When building sites or web apps with Django, Filestack’s advanced UI integrations let you offer an excellent experience to your users and the powerful APIs let you manage all your file management needs seamlessly.

Filestack’s scalable infrastructure has a 99.99% upload success rate, powers billions of reliable file uploads monthly (even on poor networks). Arguably, it’s the #1 developer service for uploads.

The best part is…

You can get started with Filestack today, for FREE.

It’s easy — sign up for a free Filestack account and start enjoying seamless file uploads and performance in your web projects.





Read More →