When you first start learning FastAPI, you’ll quickly come across three terms that seem confusing:

1.Path Parameters

2.Query Parameters

3.Request Bodies

At first, they all appear to do the same thing—they send data to your API.

But each one has a completely different purpose.

Let’s understand them in the simplest way possible.

Imagine You’re Ordering Pizza

Suppose a pizza shop has an online ordering system.

There are three different ways customers send information.

1. Which pizza do you want?

/pizza/5

The number 5 identifies the pizza.

This is called a Path Parameter because it is part of the URL path itself.

2. What extra options do you want?

/pizza/5?size=large&cheese=yes

Here we’re not changing which pizza we want.

We’re simply giving additional options.

These are called Query Parameters.

3. What is your delivery information?

{
    "name": "Tarun",
    "address": "Chennai",
    "phone": "9876543210"
}

This information is too large to place inside the URL.

Instead, it’s sent inside the request body.

This is called a Request Body.

Path Parameters

A path parameter becomes part of the URL.

Example:

from fastapi import FastAPI

app = FastAPI()

@app.get("/students/{student_id}")
def get_student(student_id: int):
    return {"Student ID": student_id}

If someone visits

/students/12

FastAPI automatically stores

student_id = 12

and returns

{
    "Student ID": 12
}

Why use Path Parameters?

Use them whenever you want to identify one specific item.

Examples include:

/users/7
/products/25
/books/103
/orders/9001

Each URL points to one unique object.

Query Parameters

Query parameters begin after a question mark.

Example:

/students?branch=CSE

or

/products?price=500&sort=asc

These parameters filter, search, or customize results.

FastAPI example:

@app.get("/students")
def get_students(branch: str):
    return {"Branch": branch}

Calling

/students?branch=ECE

returns

{
    "Branch": "ECE"
}

Why use Query Parameters?

They help users customize responses.

Examples include:

1. Searching

2. Filtering

3. Pagination

4. Sorting

For example:

/products?category=laptop
/products?price=50000
/products?page=2

Path vs Query Parameters

Think of it this way:

Path Parameters answer:

“Which item?”

Query Parameters answer:

“How do you want it?”

For example,

/movie/12

means

Show movie number 12.

While

/movie/12?language=tamil

means

Show movie 12 in Tamil.

Request Bodies

Sometimes users send lots of information.

For example, while creating an account.

Name
Email
Password
Age
Phone

Sending all of this inside the URL would be messy.

Instead, it goes inside the request body.

FastAPI uses Pydantic to understand this data.

What is Pydantic?

Pydantic is a Python library that validates incoming data automatically.

Imagine it as a strict school teacher.

If the user sends incorrect data, Pydantic immediately rejects it.

Creating a Pydantic Model

from pydantic import BaseModel

class Student(BaseModel):
    name: str
    age: int
    department: str

This class describes exactly what data your API expects.

Using the Model

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Student(BaseModel):
    name: str
    age: int
    department: str

@app.post("/students")
def create_student(student: Student):
    return student

If the user sends

{
    "name":"Tarun",
    "age":21,
    "department":"CSE"
}

FastAPI validates everything automatically.

What Happens If Data Is Wrong?

Suppose someone sends

{
    "name":"Tarun",
    "age":"twenty one",
    "department":"CSE"
}

FastAPI immediately returns an error because age must be an integer.

You don’t need to write validation code yourself.

Why Developers Love Pydantic

Without Pydantic, developers manually check every field.

With Pydantic:

1.Required fields are checked automatically.

2.Data types are validated.

3.Helpful error messages are generated.

4.Cleaner code is written.

Real-Life Example

Imagine a shopping app.

GET /products/10

Find product number 10.

GET /products?category=electronics

Show only electronics.

POST /products

Create a new product using a request body containing the product details.

Each method serves a different purpose, making APIs organized and easy to use.

Final Thoughts

FastAPI keeps API development simple by separating information into three categories:

Path Parameters identify a specific resource.

Query Parameters customize or filter the response.

Request Bodies send detailed data to the server.

Once you understand these three concepts, you’ll be able to build APIs that look and behave like those used in real-world applications.