Send Parameters to POST Request FastAPI

In the world of web development and API creation, sending parameters via a POST request is a fundamental operation. FastAPI, a modern Python web framework, simplifies this process and allows developers to build efficient and scalable APIs. In this article, we will explore the theory and practical aspects of sending parameters to a POST request using FastAPI. FastAPI is a Python framework designed to streamline API development. It provides an intuitive and efficient way to define API routes, handle requests, and validate input parameters, making it a powerful tool for developers.

Here in this article, our main focus is on the HTTP requests, especially the POST method. When you send a POST request, you are submitting data to be processed to a specified resource. Parameters play a crucial role in this data transmission, as they carry the necessary information for the request. If you have no idea of how to create a FastAPI app refer to this article FastAPI application.

Send Parameters to POST Request FastAPI

We need to install FastAPI and Uvicorn, Here is FastAPI For creating API. For testing our API we need a server, so for that, we need a uvicorn.

Installing FastAPI and uvicorn server

pip install fastapi
pip install uvicorn

Setting Up FastAPI Application

We start by creating a new directory/folder for our project. we can name it something like "fastApiGfg". Now, In your project directory/folder, create a Python file named main.py. This will be the main entry point for our FastAPI application. So our project structure is now set for writing the actual code to create API using fastAPI.

Create a Python script (e.g., main.py) and add the following code to create a basic FastAPI application that accepts POST requests with parameters.

Here, an instance of the FastAPI class is created, which will be used to define routes and handle HTTP requests.

app = FastAPI()

This line defines a route named "/create_user/" that accepts HTTP POST requests. The route is decorated with @app.post, indicating that it should handle POST requests. It specifies that two parameters, user_id (an integer) and username (a string), are expected to be sent in the request data.

@app.post("/create_user/")

This line defines an asynchronous function named create_user. The function takes one parameter, user_data, which is expected to be of type User. It implies that the function expects a JSON request body with the structure defined in the User model.

async def create_user(user_data: User)

Finally, this line runs the FastAPI app using the uvicorn.run function. It specifies the host as "127.0.0.1" and the port as 8000, meaning the web service will be accessible at http://127.0.0.1:8000

uvicorn.run(app, host="127.0.0.1", port=8000)

from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class UserCreate(BaseModel):
    user_id: int
    username: str
@app.post("/create_user/")
async def create_user(user_data: UserCreate):
    user_id = user_data.user_id
    username = user_data.username
    return {
        "msg": "we got data succesfully",
        "user_id": user_id,
        "username": username,
    }


if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="127.0.0.1", port=8000)

Deployement of the Project

We can run this code as we run simple Python code file.

Now to test our API we need to send POST request on "http://127.0.0.1:8000/create_user/" with a JSON request body containing user data, including "user_id" and "username" here we will use postman for testing our API.

Output

Here we are using Postman to test aur API.Here we have sent the data with the help of POST request.

Here we have sent 2nd set of data with the help of POST request.