Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

The Complete FastAPI Course With OAuth & JWT Authentication

Name: The Complete FastAPI Course With OAuth & JWT Authentication
Rating: 4.5 (1949 reviews)

Learn how to built modern, authenticated REST API with FastAPI, Python, SQLAlchemy, OAuth & JWT

Created byAshutosh Pawar

Last updated 7/2026

English

German [Auto],English [Auto],

What you'll learn

Develop APIs quickly using FastAPI
Learn to model data for providing API response
Learn how to connect an API to a database
Use SQLAlchemy to perform operations like create, read, update & delete data
Make API requests to manipulate database data
Send different status codes from an API
Handle exceptions for invalid API requests
Establish relationships between multiple data models
Create metadata for API
Use API router to modularise API routes
Protect API routes using authentication mechanisms
Generate JWT tokens to validate API requests

Course content

8 sections • 55 lectures • 4h 47m total length

Introduction2:47
Learn FastAPI with a practical overview and setup. Then master path and query parameters, request bodies, Pydantic models, database connections, CRUD, relations, API router, and OAuth with JWT authentication.
What is an API14:14
Learn how an API, an application programming interface, enables programs to exchange data via a standard interface. Discover RESTful design, HTTP methods like GET and POST, and JSON responses.
Introduction To FastAPI8:14
Installing FastAPI on Mac1:58
Open the FAPI project in VS Code, create and activate a virtual environment named env, then install fast API with pip, ensuring Python 3.6 or above.
Creating A Simple API9:25
Quiz 1: FastAPI Basics

Path Parameters4:45
Learn how path parameters in FastAPI convert static routes into dynamic endpoints like /property/1, returning a JSON response. Enforce integer path parameters to prevent string values.
Path Parameters With Type3:49
Automatic Documentation3:24
Ordering Of Routes3:54
Master route ordering is crucial in FastAPI to ensure specific routes, like admin, trigger over generic user routes. Place more specific routes before broader ones to avoid path parameter clashes.
Query Parameters5:11
Using Path & Query Parameters Simultaneously3:58
Create a FastAPI route that uses a path parameter and a query parameter to display a user's profile and comment, returning a json with user id and comment id.
Required Query Parameters2:36

Request Body3:16
POST Method5:03
Pydantic Models With Request Body6:20
Define a profile data model with a Pydantic base model and use it as the request body in a FastAPI POST endpoint. Return the submitted name, email, and age.
Using Model Inside A Function6:41
Passing Path & Query Parameters To Request4:28
Learn to pass path parameters, query parameters, and a request body in a FastAPI route, returning the product and its id, with category examples.
Passing Multiple Models2:50
Defining Fields For Metadata4:14
Nesting Python Datatypes In A Model6:40
Learn to nest Python data types in a model by adding a tags field as a string list, then switch to a set to enforce uniqueness.
Nesting Pydantic Models7:29
Learn how to nest pydantic models by embedding an image model inside a product model, using HTTP URL, and validating lists of images for complex attributes.
Deeply Nested Models4:02
Learn to build deeply nested Pydantic models, with offers containing products and products containing images, in a FastAPI app.
Providing Example Data5:43
Defining Example Data Using Fields4:51
Time Data Types6:44
Learn to use uuid, date, date time, time, and time delta in a dummy event model, showing how to capture start date, end time, and other time sensitive fields.
Forms To Submit API Data4:12

Introduction To Connecting To Database3:42
Learn how to connect a FastAPI API to a database, and compare relational and non-relational databases. Use SQLAlchemy as an ORM to map tables to classes and avoid writing SQL.
Creating A Project7:30
Creating A Connection3:56
Learn how to set up a FastAPI database connection with SQLAlchemy by configuring an engine, declarative base, and session maker for a SQLite database (product.db) in a separate database.py.
Creating A Model6:46
Define a product model with id, name, description, and price using SQLAlchemy’s declarative base and set the table name to products.
Using Sqlite Viewer1:24
Use the SQLiteViewer extension in VS Code to view product.db, inspect the products table with id, name, description, price, and learn how API submissions get stored.

Adding Data To Database10:29
Fetching Products6:02
Deleting Products4:08
Learn to create a FastAPI delete route to remove a product by ID, using app.delete, a path parameter, and a database session to filter, delete, and commit.
Creating A Route To Update Prodocuts6:03
Response Model5:42
Define a pydantic response model to tailor API outputs with show product, select fields such as name and price, and use list[schemas.showProduct] for product lists.
HTTP Status Codes4:58
Raising Exceptions3:48

Creating Sellers9:20
Hashing Passwords4:50
Response Model For Seller2:17
Define a display seller response model in fastapi to hide passwords, exposing only username and email on seller creation by applying the schema to the route.
Establishing Relationships Between Models8:47
Establish a one-to-many relationship between seller and product models by using a seller_id foreign key, and configure SQLAlchemy relationship with back_populates to access related objects.
Adding Metadata5:44
Add metadata to the FastAPI documentation by configuring the app with title, description, version, terms of service, contact, and license, and organize routes with OpenAPI tags and a docs link.
Using API Router9:07
Using Router For Seller Routes3:40
Defining Tags & Prefix3:40
Define tags and a common prefix on the api router to group product and seller routes, removing per-route tags and confirming with get all products and get by id.

Introduction To Authentication With JWT1:50
Learn how to implement authentication in a FastAPI API using JWT tokens, create a login route with username and password, issue a time-limited JWT, and protect routes.
Creating Login Route4:10
Logging In The User8:05
Significance Of JWT Token1:26
Utility Function To Create JWT Token7:47
Create a JWT token utility in FastAPI by installing python-jose and cryptography, generating a secret key, setting an expiration, defining token models, and encoding the token with jose.
Generating JWT Token3:21
Get Current User4:50
Protecting Routes5:03
Protect routes in your FastAPI API by requiring authentication for the all products route using a current user dependency. Implement OAuth2 password request form and JWT tokens to secure access.

Requirements

Basic knowledge of Python is essential

Description

The Complete FastAPI Course: Build API with Python & FastAPI [2026]

Note: Course is fully updated on 10th July 2026

Here Is What You Get By Enrolling In This Course:

Word-By-Word Explanation: In the entire course, I explain each line of code, without skipping a single line of code.

Awesome Quality Content: Over 5+ hours of HD(1080p) Videos.

Well Structured & Easy To Learn: Course has been specially designed to make it easy for the students to learn how to build APIs using FastAPI & Python.

24 X 7 Support: I will always be there to guide you in your journey to become a FastAPI expert.

Here Is A Brief Introduction About This Complete Course:

FastAPI is one of the most modern, fast and efficient framework for building APIs.

If you want to learn how to built high performance APIs then FastAPI should be your go to framework.

In this course we will learn FastAPI right from scratch and by then end of the course you will be able to build a complete API which supports authentication, JWT tokens, relational models and protected API routes.

This course is designed in a way that even a complete beginner can get started building APIs without even knowing what an API is.

We start off with the basics such as understanding what an API is and what purpose it serves.

We will then learn the different approaches/ frameworks to build APIs with Python and how they compare with FastAPI.

The entire course is divided into 8 sections as follows:

Section 1: Introduction & Installation.

This section covers what an API is and the purpose and API serves. We also jump into learning about the FastAPI framework and how it helps create high performance APIs in no time. We will also learn how to setup and install FastAPI framework in a virtual environment and will create our first and the most basic API.

Section 2: Path & Query Parameters

APIs accept queries in form of URL requests. In this section we learn what are path and query parameters and how they can be used for form a request body to make API calls. We learn how to program APIs in a way such that they respond as per the data sent to it from path and query parameters. We also learn how to use both the parameters simultaneously in a single API route.

Section 3: Models & Request Body.

While working with APIs we need a way to model data, be it request or response data. With FastAPI, we can use Pydantic models which allow us to create data models that can be used to define the structure of data. We learn how to create Pydantic models and use them inside API routes

Section 4: Connecting to the database.

In this section we learn how to establish a connection with the database. We will be using the SQLAlchemy library as on object relational mapper which maps tables into classes and table rows into objects, that way database data can be manipulated without having to write any SQL queries. We learn how to create SQLAlchemy models and later convert them into database tables at the backend. We use a tool called table plus to visualize database data.

Section 5: Performing CRUD operations.

Once the database connection is established, we then learn how to perform operations like create, read, update and delete on the database data. We create separate routes for each of these operations and also learn how to raise exceptions with HTTP error codes whenever the API receives an invalid request.

Section 6: Creating Multiple Models & Establishing Relationship.

After performing the database operations on a single model, we then learn how to create multiple models and establish a connection between them using a foreign key. We also learn how to securely store hashed passwords in a database using a library called Bcrypt. Along with it we also learn how to add metadata to our API and modify contents on the documentation page.

Section 7: Using API Router.

Writing modular code is always preferable when it comes to any software and same is the case with APIs as well. Using API routes, we can split different routes into multiple files so that the code becomes modular and maintainable. We learn how to use routers and split the main API code into separate modules using an API router.

Section 8: Authentication.

This section covers how to validate user credentials via an API route. Once the credentials are found to be valid, we then generate a JWT token for every logged in user. JWT tokens help us prevent access to API routes from unauthorized users. We learn how to create an assign JWT tokens to users so they can securely access API routes.

So let's begin the journey of becoming an expert API developer.

In addition to the Udemy 30-day money back guarantee, you have my personal guarantee that you will love what you learn in this course. If you ever have any questions please feel free to message me directly and I will do my best to get back to you as soon as possible!

Make sure to enrol in the course before the price changes.

Take yourself one step closer towards becoming a professional API developer by clicking the "take this course button" now!

Join the journey.

Sincerely,

Ashutosh Pawar :

Who this course is for:

Python developers who want to learn an efficient, modern and faster way to create a APIs
Developers who want to create performant APIs

The Complete FastAPI Course With OAuth & JWT Authentication

What you'll learn

Explore related topics

Course content

Introduction & Installation5 lectures • 37min

Path & Query Parameters7 lectures • 28min

Request Body & Pydantic Models14 lectures • 1hr 13min

Connecting To Database5 lectures • 23min

Performing CRUD Operations7 lectures • 41min

Creating Multiple Models & Establishing Relationships8 lectures • 47min

Authentication8 lectures • 37min

Conclusion1 lecture • 2min

Requirements

Description

Who this course is for: