Skip to content

Streamlit Upload File: Mastering File Upload and Display with Python

Welcome to the world of Streamlit, a Python framework making the creation of web applications as smooth as a breeze. An important feature Streamlit boasts is its efficient file uploading system, which we will comprehensively unpack in this guide.

File upload functionality in any web application is a critical feature that enables user interaction. It allows users to input their data for various reasons, such as data analysis, image processing, or file conversion. In the context of Streamlit, the file upload feature gains additional significance. It enables data scientists and machine learning enthusiasts to manipulate, visualize, and interact with their datasets directly. Let's dive into the inner workings of Streamlit's file upload feature and explore its full potential.

Want to Create a Data Analysis & Data Visualization App within Streamlit for free?

PyGWalker (opens in a new tab) is a Python Library that helps you easily embed a tableau-alternative UI into your own Streamlit app effortlessly. Check out this amazing video how to explore data with pygwalker (opens in a new tab) demonstrating the detailed steps for empowering your Streamlit app with this powerful Data Visualization Python Library!

Special Thanks to Sven and his great contribution (opens in a new tab) to PyGWalker community!

Additionally, you can also check out PyGWalker GitHub Page (opens in a new tab) for more PyGWalker examples.

Streamlit File Upload Widget: Your Gateway to File Upload

What is a Streamlit file upload widget, you ask? It's a unique component Streamlit offers to make file uploads a seamless process. The file upload widget provides an interactive interface where users can upload their files with the click of a button.

In a Streamlit app, implementing a file upload widget is a piece of cake. The function streamlit.file_uploader does all the heavy lifting. Just provide a string argument which is the title of the file uploader.

Here's a quick example:

import streamlit as st
uploaded_file = st.file_uploader("Choose a CSV file", type='csv')

In the above code, 'Choose a CSV file' is the title of the file uploader and type='csv' restricts the file type to CSV files.

How to Upload a File in Streamlit: Unveiling the Process

Uploading a file in Streamlit is a no-brainer thanks to the simplicity and user-friendliness of the library. The uploaded file is stored in memory as a temporary file and you can manipulate it like any other file object.

Streamlit supports a multitude of file types, including but not limited to images, audio, video, CSV, and PDF. Let's understand the file upload process with a more comprehensive example.

import streamlit as st
uploaded_file = st.file_uploader("Choose your file", type=['csv', 'png', 'jpg'])
if uploaded_file is not None:
    # To read file as bytes:
    bytes_data = uploaded_file.getvalue()
    # To convert to a string based IO:
    stringio = StringIO(uploaded_file.getvalue().decode("utf-8"))
    # To read file as string:
    string_data =

In this example, we've expanded the file types to CSV, PNG, and JPG. Once the file is uploaded, you can either read it as bytes, convert it to a string-based IO, or directly read it as a string.

Displaying the Uploaded File: From Data to Visualization

The joy of uploading a file truly comes when you can use that file for further processing and visualization. So, how do you display the uploaded file in Streamlit? The answer is simpler than you might think.

Let's assume you've uploaded a CSV file and you want to visualize it as a data frame using Pandas. Here's how you can do it


import streamlit as st
import pandas as pd
uploaded_file = st.file_uploader("Upload a CSV file", type='csv')
if uploaded_file is not None:
    data = pd.read_csv(uploaded_file)

This code will display the data frame directly in your Streamlit app, enabling you to proceed with data manipulation or visualization.

Handling Multiple File Uploads: The Power of Bulk Data

Now that we have conquered single file uploads, let's level up. Can you upload multiple files in Streamlit? Absolutely! This feature can be particularly helpful when you're dealing with multiple datasets or bulk images, audio files, and more.

To upload multiple files, simply set the accept_multiple_files parameter to True in the st.file_uploader function.

import streamlit as st
uploaded_files = st.file_uploader("Choose your files", accept_multiple_files=True)
for uploaded_file in uploaded_files:

While uploading multiple files, you need to be aware of Streamlit's file upload size limit. By default, Streamlit allows a maximum upload of 200MB. However, you can modify this limit in the Streamlit configuration file.

That's the first four parts of our guide covered! We've seen how Streamlit empowers us with easy file upload processes, from single to multiple files. But we're not stopping here! Stay tuned as we journey into advanced topics like validation, security, and more, in the next parts of our guide.

Streamlit File Upload Progress Bar: Track Your Uploads

Now that we've tackled multiple file uploads, you may wonder if there's a way to track the upload process. Streamlit has you covered here as well with the Streamlit file upload progress bar. It shows up automatically during file upload, giving users real-time feedback about the upload process. It's all handled internally by Streamlit, so no extra code is required from your side!

Advanced Topics in File Upload

Next up, let's dive into some advanced topics related to Streamlit file uploads, starting with file upload validation.

Streamlit File Upload Validation

You might need to verify the uploaded file's type or size to ensure it's suitable for your application. This process is known as file upload validation. In Streamlit, you can set the type parameter in the st.file_uploader function to restrict the file types that can be uploaded.

Moreover, you can implement custom validation checks after the file is uploaded. For example, you can verify the content of a CSV file to ensure it has the required columns.

Security of Streamlit File Upload

Security is a paramount concern when handling file uploads. The good news is that Streamlit takes security seriously. All uploaded files are stored in memory, not on disk. When the script reruns, Streamlit deletes the old uploaded files. However, it's always advisable to implement additional security measures depending on your specific use case.

Streamlit File Upload to S3

If you want to store the uploaded files for later use, you might consider uploading them to a storage service like AWS S3. While Streamlit doesn't provide a built-in function for this, it's straightforward with the boto3 library. Once you have the file object from st.file_uploader, you can upload it to S3.

Streamlit File Upload to Database

Similarly, you may want to store uploaded files or their data directly into a database. Once the file is uploaded to Streamlit, you can process it and save the data to your database using the appropriate Python library for your database.

Streamlit File Upload in Machine Learning

In the context of machine learning projects, Streamlit's file upload functionality shines brightly. It allows users to upload datasets directly into the app. You can then process the data, build models, make predictions, and even display the results, all within the app!

For instance, a user can upload an image, which a machine learning model then processes to identify objects or classify the image. The possibilities are vast and exciting!


In this comprehensive guide, we've uncovered the potential of Streamlit's file upload feature. From the basics of single file uploads, through handling multiple files, to discussing advanced topics like validation and security, we've covered it all. We even touched upon how to integrate Streamlit file upload with AWS S3 and databases. With these tools in your arsenal, you're well-equipped to create engaging and interactive web applications using Streamlit.

Have you heard of this awesome Data Analysis & Data Visualisation tool, that turns your Streamlit App into Tableau?

PyGWalker (opens in a new tab) is a Python Library that helps you easily embed a tableau-alternative UI into your own Streamlit app effortlessly.

PyGWalker for Data visualization in Streamlit (opens in a new tab)

Frequently Asked Questions

1. How do I upload files to Streamlit?

You can upload files to Streamlit using the st.file_uploader function. This function provides a widget in your Streamlit app through which users can upload their files.

2. Where does Streamlit store uploaded files?

Streamlit stores uploaded files in memory, not on disk. These files are treated as temporary files and are deleted when the script reruns.

3. How do I upload an API file?

Streamlit's st.file_uploader can handle any file type, including API files. Once the file is uploaded, you can process it according to your needs.

4. What is the upload size for Streamlit?

By default, Streamlit allows a maximum upload size of 200MB. However, this limit can be modified in the Streamlit configuration file.