FastAPI is a modern, high-performance web framework for building APIs with Python.
It’s gaining popularity for its ease of use, speed, and powerful features.
Learning FastAPI enables you to create robust and scalable APIs, making you a valuable asset in the world of web development.
It allows you to build RESTful APIs quickly, making it perfect for modern web applications.
Finding the right FastAPI course on Udemy can be tricky, with many options available, but you’re looking for a course that is comprehensive and teaches you how to build APIs from the ground up.
For the best FastAPI course overall on Udemy, we recommend FastAPI - The Complete Course 2024 (Beginner + Advanced).
This course covers everything from the basics of FastAPI to advanced topics like database integration, authentication, and deployment.
It features a ton of hands-on projects, making it a great choice for beginners and experienced developers alike.
But that’s not all!
We have a whole list of fantastic FastAPI courses on Udemy tailored to different needs and learning styles.
From beginner-friendly introductions to courses focused on specific topics like authentication or database integration, keep reading for more great options!
FastAPI - The Complete Course 2024 (Beginner + Advanced)
This course is a comprehensive guide to learning FastAPI.
It starts with a Python refresher, covering fundamentals like variables, data structures, functions, and object-oriented programming concepts.
This lays a solid foundation before diving into FastAPI.
You’ll build your first FastAPI project, learning how to create endpoints for different HTTP request methods like GET, POST, PUT, and DELETE.
The course emphasizes data validation using Pydantic, ensuring your APIs are robust and secure.
You’ll also learn about path and query parameters, status codes, and exception handling.
As you progress, the course covers more advanced topics like database integration with SQLite3, PostgreSQL, and MySQL using SQLAlchemy ORM.
You’ll learn to create, read, update, and delete data from these databases through your FastAPI endpoints.
Authentication and authorization are crucial aspects covered in-depth, including JSON Web Tokens (JWT) for authentication and role-based access control.
The course guides you through setting up user registration, login, and securing your APIs.
Testing is an essential part of software development, and the course dedicates a section to unit and integration testing with Pytest.
You’ll learn how to write tests for your FastAPI applications, ensuring they function as expected.
The course culminates in building a full-stack application with FastAPI, integrating HTML templates, CSS, and JavaScript.
You’ll learn how to create a complete web application with both APIs and a user interface.
Throughout the course, you’ll also learn about version control with Git and GitHub, as well as deploying your FastAPI applications to platforms like Render.
With hands-on projects and assignments, you’ll gain practical experience in building robust and scalable APIs, integrating databases, implementing authentication and authorization, testing, and deploying your applications.
Complete FastAPI masterclass from scratch
You will start by installing FastAPI on your Windows or Mac system and understanding its key features.
The course covers the fundamentals of building APIs, including handling GET requests, working with path parameters, query parameters, and request bodies.
You’ll learn how to add descriptions, tags, and response models to your API endpoints, making them more readable and maintainable.
As you progress, you’ll dive into advanced topics like routers, which help organize your API endpoints, and validators, which ensure data integrity.
The course also covers database integration using SQLAlchemy, allowing you to create, read, update, and delete data in a database.
Error handling, custom responses, headers, cookies, form data, and CORS are covered, ensuring you can build robust and secure APIs.
Authentication is also explored, with lessons on token generation and user authentication.
Working with files is an essential skill, and you’ll learn how to upload, download, and serve static files using FastAPI.
The course also covers important aspects of development, such as deployment, debugging, testing, and logging.
You’ll explore advanced concepts like async/await, templates, middleware, background tasks, web sockets, and dependencies.
Practical projects like an OCR application, a blog site, and an Instagram clone (both backend and frontend) will solidify your understanding.
The course culminates with a warehouse application built using microservices and Redis, showcasing real-world scenarios and best practices.
Throughout the course, you’ll gain hands-on experience building APIs, integrating databases, handling authentication, working with files, and deploying applications.
By the end, you’ll be equipped with the skills to build robust and scalable APIs using FastAPI.
The Complete FastAPI Course With OAuth & JWT Authentication
You’ll start by learning the fundamentals of APIs and installing FastAPI on your system.
From there, you’ll dive into creating simple APIs and working with path and query parameters.
The course covers request bodies and Pydantic models, which allow you to define data structures for your API requests and responses.
You’ll learn how to handle nested models, provide example data, and work with different data types like dates and times.
A major focus is connecting your API to a database and performing CRUD (create, read, update, delete) operations.
You’ll use a tool called Table Plus to interact with the database directly.
The course also covers defining multiple models and establishing relationships between them.
For authentication, you’ll learn how to implement JSON Web Tokens (JWT) to secure your API routes.
This includes creating login routes, generating JWT tokens, and protecting certain routes based on the user’s authentication status.
The course goes beyond just building APIs by teaching you how to organize your code using API routers, defining tags and prefixes for better organization.
You’ll also learn about handling HTTP status codes and raising exceptions when necessary.
Throughout the course, you’ll work with practical examples and build a complete API application.
This hands-on approach will help you solidify your understanding of FastAPI and its various features.
FastAPI Full Stack Web Development in 2024
You will start by learning the fundamentals of FastAPI, including HTTP verbs, project configuration, and version control with Git and GitHub.
Next, you’ll dive into advanced Python concepts like type hints, iterators, generators, and asynchronous programming.
These topics are essential for writing clean, efficient, and maintainable code with FastAPI.
Once you have a solid foundation, the course will walk you through building the core components of a FastAPI project.
You’ll learn how to connect to databases like PostgreSQL and SQLite, create data models with SQLAlchemy, and implement user registration with password hashing.
The course also covers dependency injection, a powerful technique for managing dependencies in your application.
With the building blocks in place, you’ll move on to developing APIs with FastAPI.
You’ll create routes for common CRUD operations on resources like blogs, handle responses and status codes, and practice writing raw SQL queries.
Importantly, the course emphasizes testing, teaching you how to write unit tests for your APIs using Pytest.
The course then shifts gears to authentication and authorization, covering JSON Web Tokens (JWT) for secure authentication and role-based access control.
Finally, you’ll learn how to build a complete web application with FastAPI.
This includes serving HTML templates, static files, implementing user registration and login forms, and creating views for listing and displaying blog posts.
Throughout the course, you’ll work on a real-world project, applying the concepts you learn to build a fully-functional web application from scratch.
The FastAPI SuperGuide: Create 3 Real-World FastAPI Apps
The course covers three real-world FastAPI projects, allowing you to gain practical experience.
You’ll start with an introduction to FastAPI, including setting up your environment and installing the necessary libraries.
The course then dives into advanced Python concepts, REST architecture, CRUD operations, HTTP requests, type hints, and Pydantic models.
You’ll even have coding exercises to design a social media post model using Pydantic.
The first project is a Car Information Viewer app, where you’ll build a basic FastAPI application with Jinja templates and Bootstrap.
You’ll learn to create car models, implement CRUD operations, set up HTML templates, design a navbar, create components, add search and CRUD features, and more.
The second project is a Social Media Feed with user login, utilizing OAuth2, JWT, and security features.
You’ll create models, set up login and registration mechanisms with password hashing, display user information, and implement notifications.
The third project is a Todo List app integrated with SQL and UUID.
You’ll set up a database, create models and schemas, implement login and registration with authentication, and build a todo page with CRUD functionality for tasks.
Throughout the course, you’ll encounter quizzes to reinforce your understanding of key concepts like REST architecture, type hints, Pydantic models, OAuth2, JWT, web security, SQL, and SQL integration.
Mastering REST APIs with FastAPI
You will start by learning the fundamentals of APIs and REST architecture, setting the foundation for your journey.
As you progress, you will dive into the core of FastAPI, building your first application and learning essential techniques like linting, formatting, and structuring your code.
The course covers crucial aspects such as routing, handling requests, and working with databases using async operations.
You will learn how to implement user authentication with JSON Web Tokens (JWTs), enabling secure access to your API.
The course also covers advanced topics like logging, exception handling, and correlation IDs for better traceability.
Moving forward, you will explore many-to-many relationships, query string arguments, and data sorting using enums.
The course teaches you how to implement user email confirmation, file uploads with Backblaze B2, and background tasks for image generation using DeepAI.
Throughout the course, you will gain hands-on experience by building a social media API, complete with features like posts, comments, and likes.
You will also learn how to write comprehensive tests using pytest, ensuring your code is robust and maintainable.
Finally, the course covers deployment strategies, including continuous integration with GitHub Actions and hosting your FastAPI application on Render with a PostgreSQL database.
You will also learn how to integrate Sentry for error management, ensuring your application is production-ready.
FastAPI for Busy Software Engineers
You’ll start by learning the basics of FastAPI, including path and query parameters, and how to use Pydantic for data validation.
The course covers error handling and integrating Jinja2 templates for serving HTML.
You’ll then dive into adding a database using SQLAlchemy and managing migrations with Alembic.
As you progress, you’ll learn how to structure FastAPI projects for production environments and leverage FastAPI’s async capabilities.
Authentication is a crucial aspect covered through JSON Web Tokens (JWTs), including user creation and login functionality.
The course also explores dependency injection in FastAPI and how to write tests for your application.
To provide a complete learning experience, the course guides you through integrating a modern React frontend, covering architecture, codebase overview, and implementing features like homepage, authentication, and user profiles.
Deployment is a key focus, with hands-on lessons on Dockerizing your FastAPI application, running it locally, and deploying to Heroku.
The course also covers adding realism through email sending with Mailgun, background tasks, and logging.
Throughout the journey, you’ll have access to a project codebase and lecture notes, ensuring you can follow along and reinforce your learning.
The course wraps up with an FAQ and troubleshooting section to address common issues.
Build & Deploy Secure API with Python FASTAPI JWT SQLAlchemy
You’ll start by setting up your development environment, including installing Python, PyCharm, and the necessary libraries.
Next, you’ll dive into working with databases, models, and relationships.
You’ll learn how to create database configurations, user and post models, and establish relationships between them.
The course covers working with schemas, database sessions, and tables, as well as implementing password verification logic.
Moving on, you’ll set up the main app and create schema classes for users and posts.
You’ll also learn about JWT (JSON Web Tokens) and its components, as well as how to implement user registration and login functionality using JWT.
Once you’ve mastered user authentication, you’ll learn how to create, read, update, and delete posts.
This includes implementing API endpoints for creating posts, getting posts by user, getting post details, updating posts, and deleting posts.
You’ll also learn how to get all posts from all users.
The course covers advanced topics like implementing user detail functionality and connecting to MySQL and PostgreSQL databases.
Finally, you’ll learn how to deploy your application to the cloud (Heroku), enable CORS (Cross-Origin Resource Sharing), and push your code to GitHub.
Hands-On Beginner FastAPI and SQLModel
This course takes you on a comprehensive journey, starting from the basics of setting up your development environment to building full-fledged APIs and integrating them with databases.
You’ll begin by learning how to create your virtual environment and set up the necessary tools.
From there, you’ll dive into designing data models and creating your database.
The course even guides you through getting a database browser, which can be incredibly helpful for visualizing and interacting with your data.
Once you have the foundation in place, you’ll learn how to design and define API functions.
You’ll explore techniques for returning HTML code and posting data through the API.
The course also covers essential topics like debugging with breakpoints and improving API responses.
As you progress, you’ll learn how to interact with databases using FastAPI.
You’ll learn how to retrieve data, update rows, and delete rows.
The course also covers advanced topics like better request schemas, server-side validations, sorting, and searching.
Working with multiple related tables is a crucial skill, and this course has you covered.
You’ll learn how to handle booleans, dates, and defaults, as well as using regex validation.
The course even dives into specific use cases like posting videos, deleting and undeleting videos, getting active videos, and updating videos.
You’ll also learn about joining tables, custom column names, and counting rows.
The course then transitions to FastAPI templating and HTML, covering static files, creating HTML layout pages, and building HTML forms for creating new rows and posting data from those forms to the database.
You’ll even learn how to enhance the user experience with features like dropdown lists, displaying data in HTML tables, click-to-edit updating, and FastAPI redirects.
Finally, the course wraps up by teaching you how to handle deletes and customize page titles.
Python REST API with FastAPI, Amazon RDS & Elastic Beanstalk
The course starts by introducing FastAPI.
You’ll learn how to install FastAPI and create your first project, covering fundamental concepts like path parameters, query parameters, and request bodies.
From there, the course dives into working with databases and models in FastAPI.
You’ll learn how to insert, retrieve, update, and delete data using MySQL as the database.
The course then guides you through setting up an Amazon RDS instance to host your MySQL database in the cloud.
Once you have a solid understanding of FastAPI and databases, the course shifts gears to deployment.
You’ll learn how to deploy your FastAPI application to Heroku, a popular cloud platform.
But that’s not all – the course also covers deploying to Amazon Elastic Beanstalk, a powerful AWS service for deploying and scaling web applications.
Along the way, you’ll learn about asynchronous code in FastAPI, which can significantly improve performance.
The course also covers creating a user system with authentication using JWT tokens and protecting routes.
To ensure your application is production-ready, the course walks you through purchasing a custom domain from Amazon Route53 and adding it to your FastAPI application.
You’ll also learn how to request an SSL certificate from AWS Certificate Manager and add it to your API for secure communication.
Finally, the course introduces Tortoise ORM, an async ORM for Python that works seamlessly with FastAPI.
You’ll learn how to create databases and models, as well as perform CRUD operations using Tortoise ORM.
Throughout the course, you’ll work with key technologies like Python, REST APIs, MySQL, Amazon RDS, Heroku, GitHub, Elastic Beanstalk, Route53, AWS Certificate Manager, and Tortoise ORM.