This article is about fixing how to use Dynamic Form Data in FastAPI application function Python?
  • 31-Jan-2023
Lightrun Team
Author Lightrun Team
This article is about fixing how to use Dynamic Form Data in FastAPI application function Python?

How to use Dynamic Form Data in FastAPI application function Python? in Tiangolo FastAPI

Lightrun Team
Lightrun Team

Explanation of the problem

The issue described is related to collecting form data from an HTML form in a FastAPI application. In the example, the form data consists of text fields, and the challenge is to dynamically collect the inputs as parameters for a function. The normal method for collecting form data is to use the Form() function in FastAPI, however, this approach becomes difficult when the HTML form is dynamic, and changes according to the inputs.

In such cases, the FastAPI application must be able to dynamically adapt to the changes in the HTML form. The solution suggested in the issue is to use the request object in FastAPI, and collect the data using request.form(). This approach works well, but the challenge is that the data does not show up on the /docs endpoint of the FastAPI application. This means that the data is not visible in the Swagger docs.

The problem at hand is to collect form data from an HTML form and make it visible in the Swagger docs of a FastAPI application. The solution proposed in the issue is to use the request object in FastAPI to collect the form data, but this approach does not show the data in the Swagger docs. The issue is open, and the person posting the problem is looking for help in finding a solution that can dynamically collect the form data and make it visible in the Swagger docs of the FastAPI application.

Troubleshooting with the Lightrun Developer Observability Platform

Getting a sense of what’s actually happening inside a live application is a frustrating experience, one that relies mostly on querying and observing whatever logs were written during development.
Lightrun is a Developer Observability Platform, allowing developers to add telemetry to live applications in real-time, on-demand, and right from the IDE.

  • Instantly add logs to, set metrics in, and take snapshots of live applications
  • Insights delivered straight to your IDE or CLI
  • Works where you do: dev, QA, staging, CI/CD, and production

Start for free today

Problem solution for How to use Dynamic Form Data in FastAPI application function Python? in Tiangolo FastAPI

The solution to using dynamic form data in a FastAPI application function in Python is to use the Pydantic library in FastAPI. Pydantic is a library for validating and converting data types, and it can be used to define dynamic forms in FastAPI. The solution involves defining a Pydantic model that represents the dynamic form data, and then using this model in the function definition to collect the form data.

Here’s an example of how to use Pydantic to collect dynamic form data in FastAPI:

from fastapi import FastAPI, Header
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    description: str"/items/")
async def create_item(item: Item):
    return {"name":, "description": item.description}

In this example, the Item model defines the structure of the dynamic form data. This model is then used in the create_item function to collect the form data. The dynamic form data is passed to the function as an argument, and the function returns the collected data as a JSON response.

Note that the dynamic form data must be sent in the request body as a JSON payload, and the Content-Type header must be set to application/json.

Other popular problems with Tiangolo FastAPI

Problem: Performance with long-running requests

One of the most common issues with FastAPI is performance degradation for long-running requests. This is because by default, the server only uses a single thread to handle multiple requests, leading to slow responses for requests that take a long time to process.


To resolve this issue, you can use async support in FastAPI to handle multiple requests concurrently. This can be done by marking your request-handling functions with the “async” keyword and using the “asyncio” library for asynchronous programming. This allows you to handle multiple requests at the same time, increasing performance and reducing response times for long-running requests.

Problem: Route handling with complex parameters

Another issue that developers encounter with FastAPI is handling complex parameters in the URL. This can include nested objects, lists, and arrays, which can make the process of extracting and processing parameters more challenging.


To address this issue, FastAPI provides a “Path” parameter type, which can be used to define complex parameters in the URL. Additionally, FastAPI supports parsing request bodies as JSON objects, which can be used to handle more complex data structures in the body of a request.

Problem: Error handling

A third common issue with FastAPI is error handling. With a large number of routes and parameters, it can be difficult to manage and track errors that occur during the processing of requests.


FastAPI provides built-in error handling and exception management, making it easier to catch and manage errors. This includes support for custom exception handling and automatic error responses for common HTTP errors, such as 400 Bad Request and 500 Internal Server Error. Additionally, FastAPI provides a flexible logging system that can be used to capture and track errors and exceptions for debugging purposes.

A brief introduction to Tiangolo FastAPI

Tiangolo FastAPI is a modern, fast, web framework for building APIs with Python 3.6+ based on standard Python type hints. It uses the async/await syntax and is built on top of the Starlette library. It provides an easy-to-use interface for defining API endpoints, handling request inputs, validating data and returning responses. The API is created with high-performance in mind, which is made possible by the asynchronous nature of Python 3.6+.

One of the key features of Tiangolo FastAPI is the automatic generation of API documentation using the OpenAPI standard. The API documentation is generated from the API functions’ type annotations and is automatically updated as the API functions are changed. This makes it easier for developers to understand and consume the API, and for API users to understand the expected inputs and outputs. Additionally, Tiangolo FastAPI integrates with popular tools such as Swagger UI and ReDoc for a visually appealing API documentation experience.

Most popular use cases for Tiangolo FastAPI

  1. Building RESTful APIs: Tiangolo FastAPI can be used to build RESTful APIs for various applications. With its simple and intuitive syntax, building an API endpoint is as easy as defining a Python function and adding a decorator to specify the HTTP verb and endpoint path. An example of a RESTful endpoint in Tiangolo FastAPI:
from fastapi import FastAPI

app = FastAPI()

def read_root():
    return {"Hello": "World"}
  1. Validation of Request Data: Tiangolo FastAPI allows for easy validation of request data using the Python type hints. Input data is automatically validated based on the type hints, with built-in support for JSON request bodies, query parameters, and form data. An example of validating request data in Tiangolo FastAPI:
from fastapi import FastAPI, Header, Path

app = FastAPI()

def read_item(item_id: int, skip: int = 0, limit: int = 100):
    return {"item_id": item_id, "skip": skip, "limit": limit}
  1. Asynchronous Processing: Tiangolo FastAPI is built on top of the asynchronous Starlette library, making it easy to perform asynchronous processing of requests. This makes it suitable for building high-performance APIs, particularly when handling a large number of requests concurrently. An example of using asynchronous processing in Tiangolo FastAPI:
from fastapi import FastAPI
import asyncio

app = FastAPI()

async def read_root():
    await asyncio.sleep(5)
    return {"Hello": "World"}

It’s Really not that Complicated.

You can actually understand what’s going on inside your live applications. It’s a registration form away.

Get Lightrun

Lets Talk!

Looking for more information about Lightrun and debugging?
We’d love to hear from you!
Drop us a line and we’ll get back to you shortly.

By submitting this form, I agree to Lightrun’s Privacy Policy and Terms of Use.