File Uploads & Static Files in FastAPI

 Introduction

In real-world applications, APIs often need to handle:

  • Uploading files (images, PDFs, videos)
  • Serving static content (images, CSS, JS)

FastAPI makes this easy with built-in support for:

  • File uploads using UploadFile
  • Serving static files

File Upload in FastAPI

FastAPI provides two ways to upload files:

  1. bytes (simple, small files)
  2. UploadFile (recommended for large files)

Upload File Using UploadFile

from fastapi import FastAPI, UploadFile, File

app = FastAPI()

@app.post("/upload/")
async def upload_file(file: UploadFile = File(...)):
    return {
        "filename": file.filename,
        "content_type": file.content_type
    }

Why Use UploadFile?

1.Handles large files efficiently
2.Uses temporary storage
3.Supports async operations

Saving Uploaded File

import shutil

@app.post("/upload-file/")
async def upload_file(file: UploadFile = File(...)):
    with open(f"uploads/{file.filename}", "wb") as buffer:
        shutil.copyfileobj(file.file, buffer)

    return {"message": "File uploaded successfully"}

Make sure uploads/ folder exists.

Upload Multiple Files

from typing import List

@app.post("/upload-multiple/")
async def upload_multiple(files: List[UploadFile] = File(...)):
    return [file.filename for file in files]

Serving Static Files
To serve static files like images or CSS:
from fastapi.staticfiles import StaticFiles

app.mount("/static", StaticFiles(directory="static"), name="static")


Folder Structure Example
project/
├── app/
├── static/
│   ├── image.png
│   ├── style.css
├── uploads/
Access Static Files
Example:http://127.0.0.1:8000/static/image.png

Folder Structure Example

project/
├── app/
├── static/
│   ├── image.png
│   ├── style.css
├── uploads/

Access Static Files

Example:http://127.0.0.1:8000/static/image.png

Common Mistakes

1. Not creating upload directory
2. Using bytes for large files
3. Not validating file type
4. Exposing sensitive files

Best Practices

1.Validate file type (image, pdf, etc.)
2.Limit file size
3.Store files securely
4.Use cloud storage (AWS S3, etc.) in production


Basic File Validation Example

@app.post("/upload-image/")
async def upload_image(file: UploadFile = File(...)):
    if not file.content_type.startswith("image/"):
        return {"error": "Only images allowed"}
    
    return {"filename": file.filename}

Key Takeaways

  • FastAPI supports efficient file uploads
  • UploadFile is best for large files
  • Static files can be served easily
  • Always validate and secure file uploads 



Comments

Post a Comment

Popular posts from this blog

Database Integration in FastAPI (SQLAlchemy CRUD)

  Introduction So far, we’ve built APIs without storing data.But real-world applications need a database to: Store user data. Manage products. Persist application state. In this blog, we’ll connect FastAPI with a database using SQLAlchemy and perform CRUD operations . What is SQLAlchemy? SQLAlchemy is a powerful Python ORM (Object Relational Mapper) that allows you to: Interact with databases using Python code. Avoid writing raw SQL queries. Work with models instead of tables. Step 1: Install Dependencies pip install sqlalchemy (For SQLite, no extra driver needed) Project Structure Update app/ ├── main.py ├── database/ │ ├── connection.py ├── models/ │ ├── item.py ├── schemas/ │ ├── item.py ├── routes/ │ ├── item.py Step 2: Database Connection app/database/connection.py from sqlalchemy import create_engine from sqlalchemy . orm import sessionmaker , declarative_base DATABASE_URL = "sqlite:///./test.db" engine = create_engine ( DAT...
Read more

Middleware & CORS in FastAPI

  Introduction As your API grows, you may need to: Log requests Modify responses Handle cross-origin requests This is where Middleware and CORS (Cross-Origin Resource Sharing) come into play.They help control how requests and responses flow through your application. What is Middleware? Middleware is a function that runs: Before a request reaches your route After a response is returned Think of it as a pipeline layer between client and server. Request Flow with Middleware Client → Middleware → Route → Middleware → Response Creating Custom Middleware from fastapi import FastAPI , Request import time app = FastAPI () @ app . middleware ( "http" ) async def log_requests ( request : Request , call_next ): start_time = time . time() response = await call_next ( request ) process_time = time . time() - start_time print ( f"Request: { request . url} | Time: { process_time } " ) return response What This Middle...
Read more

Python Data Handling

Python Data Handling for Beginners In Python, data handling means storing, changing, and using data in different ways. In this post, you will learn: Lists Tuples Dictionaries Sets String Methods Type Conversion 1. Python Lists :Lists store many values in one variable.                fruits = ["apple", "banana", "mango"]                                                                       Method                          Use                                            append()          ...
Read more