How To Create Your Very First API With FastAPI In Python Tutorial 2023

4 Feb 202310:18

TLDRThis tutorial video guides viewers through the process of creating their first API using the FastAPI package in Python. It begins with the installation of FastAPI through the terminal and proceeds to demonstrate how to import necessary modules and create an application instance. The video then outlines the creation of a basic endpoint that returns a JSON response with a hardcoded value. Subsequently, it introduces uvicorn for running the API and automatically reloading it upon changes. The presenter also shows how to test the API using a local address and the 'requests' module. The tutorial further explains how to add dynamic functionality, such as generating a random number and allowing users to specify their own limit. It concludes with a mention of FastAPI's automatic API documentation generation and encourages viewers to explore further by creating more complex APIs or integrating with other services.


  • πŸ“¦ Install FastAPI by running `pip install fastapi[all]` in the terminal to get started with creating APIs.
  • 🌐 Import necessary modules: `from fastapi import FastAPI` and `import random` for generating random numbers.
  • πŸš€ Instantiate the FastAPI application by creating an instance of `FastAPI()`.
  • πŸ“„ Define endpoints with `@app.get(path)` and create asynchronous functions to handle requests.
  • πŸ” Use the `async def` syntax to create asynchronous endpoints for better performance.
  • πŸ“ˆ Return JSON responses easily by returning Python dictionaries that FastAPI automatically converts to JSON.
  • πŸ”§ Use `uvicorn` to run the FastAPI application with live reload enabled by using the `--reload` flag.
  • πŸ”¬ Test the API in a browser or with the `requests` module to make HTTP requests and retrieve responses.
  • πŸ”— Create dynamic endpoints by including path parameters within the path string using curly braces `{}`.
  • 🎚️ Allow users to specify parameters like limits for generated random numbers through URL parameters.
  • πŸ“š FastAPI automatically generates API documentation accessible via the `/docs` endpoint.
  • βœ… Remember to use the `async` keyword for route handling functions to enable asynchronous behavior.

Q & A

  • What is FastAPI and why is it used?

    -FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.7+ based on standard Python type hints. It is used for quickly creating APIs because it is easy to use and provides features like automatic data validation and serialization.

  • How do you install FastAPI in a Python project?

    -You can install FastAPI by opening the terminal in your Python project directory and typing 'pip install fastapi'. Make sure to use quotation marks around 'fastapi' to ensure all related packages are installed.

  • What is the first step to create an API using FastAPI?

    -The first step is to import FastAPI and any other necessary modules, such as 'random' for generating random numbers. Then, you create an instance of the FastAPI application which serves as the entry point to your API.

  • How do you define an endpoint in FastAPI?

    -You define an endpoint in FastAPI using the '@app.get' decorator followed by the path for the endpoint. You also define an asynchronous function that will be executed when the endpoint is accessed.

  • What is the purpose of the 'async' keyword in the function definition?

    -The 'async' keyword is used to define an asynchronous function in Python. This allows the function to be non-blocking, which is particularly useful for IO-bound tasks such as handling web requests in an API.

  • How does FastAPI handle the conversion from Python dictionaries to JSON format?

    -FastAPI automatically takes care of converting Python dictionaries to JSON format. When you return a dictionary from an endpoint function, FastAPI serializes it to JSON and sends it as the response.

  • What is the purpose of the 'uvicorn' command used in the terminal?

    -Uvicorn is an ASGI server implementation that is used to serve the FastAPI application. It allows the application to run and automatically reloads the server whenever changes are made to the code, which is very useful during development.

  • What does the 'reload' flag do when used with 'uvicorn'?

    -The 'reload' flag tells Uvicorn to automatically reload the application when it detects changes in the code. This means you don't have to manually restart the server after making changes, which speeds up the development process.

  • How can you test the API locally?

    -You can test the API locally by navigating to the provided local server address in a web browser or by using tools like 'curl' or the 'requests' module in Python to make HTTP requests to the API endpoints.

  • How does FastAPI handle user input for endpoints?

    -FastAPI allows you to capture user input through path parameters, query parameters, or request bodies. You can specify the type of the parameter and FastAPI will automatically validate and parse the input from the request.

  • What is the advantage of using path parameters in FastAPI?

    -Path parameters in FastAPI allow you to include user-defined values in the URL path itself. This is useful for creating dynamic endpoints where different users can access different resources based on the value in the path.

  • How does FastAPI generate API documentation?

    -FastAPI automatically generates API documentation that can be accessed by navigating to the '/docs' endpoint of the application. This documentation includes information about all the endpoints, their parameters, and the expected responses.



πŸš€ Introduction to FastAPI

This paragraph introduces the viewer to FastAPI, a high-performance web framework for building APIs with Python. The presenter explains how to install FastAPI using pip and import necessary modules. They then demonstrate creating a basic API by instantiating a FastAPI application and defining a root endpoint that returns JSON data. The explanation also includes how to use the uvicorn server to run and automatically reload the application upon changes.


πŸ”’ Creating a Random Number Endpoint

In this section, the presenter guides the viewer through creating a new endpoint that returns a random integer between 0 and 100. They explain how to define the endpoint using the `@app.get` decorator and an asynchronous function to generate the random number. The JSON response includes the random number and the limit used for generation. The paragraph also covers how to allow users to specify their own limit by adding a path parameter to the endpoint and adjusting the function accordingly.


πŸ“š FastAPI's Automatic Documentation

The presenter discusses the automatic documentation feature of FastAPI, which is accessible through the `/docs` endpoint. They mention that while the video does not cover how to edit the documentation, they are open to creating a follow-up video if there is enough interest. The paragraph concludes with an invitation for viewers to experiment with the API, possibly integrating it with other projects or using it for testing purposes. The presenter also provides information on how to stop the server using a keyboard interrupt.




An API, or Application Programming Interface, is a set of rules that allows different software entities to communicate with each other. In the video, the creation of an API using FastAPI in Python is demonstrated, highlighting its use to expose functionalities, like returning random numbers, to other programs or services.


FastAPI is a modern, fast (high-performance) web framework for building APIs with Python 3.6+ based on standard Python type hints. The video showcases how FastAPI makes it convenient to build a web API, emphasizing its easy-to-use features for routing and dependency injection.

πŸ’‘pip install

The command 'pip install' is used in Python to install packages from the Python Package Index (PyPI). The video begins by demonstrating how to use this command to install FastAPI, setting the stage for building the API.


In the context of web APIs, an endpoint is a specific URL where a web API can be accessed by a client application. The video describes setting up various endpoints like the root and '/random', which respond to HTTP requests with data.


Uvicorn is an ASGI server implementation, compatible with asyncio frameworks like FastAPI. It's used in the video to run the developed API locally, highlighting its ability to reload the server automatically upon code changes, which aids in development.


JSON, or JavaScript Object Notation, is a lightweight data-interchange format easy for humans to read and write and for machines to parse and generate. The video explains how FastAPI automatically converts Python dictionaries into JSON responses, which are used to communicate data in APIs.


The 'async' keyword in Python is used to define an asynchronous function that can handle I/O-bound tasks more efficiently. The video employs asynchronous functions to handle API requests, improving the performance of the API under load.

πŸ’‘reload flag

The reload flag in Uvicorn is used to automatically restart the server when code changes are detected, which is extremely useful during development. The video highlights how using the reload flag with Uvicorn allows developers to see changes in real-time without manual restarts.


The 'requests' library in Python is used for making HTTP requests simpler and more human-friendly. In the video, 'requests' is used to fetch data from the locally running API, demonstrating how to interact with APIs from a client's perspective.


In software development, documentation helps users and developers understand how to use and implement an API. FastAPI automatically generates interactive API documentation from your code, which is briefly mentioned in the video as a feature that could be explored in more depth in future tutorials.


Introduction to creating an API using FastAPI in Python

Installation of FastAPI using pip with the terminal

Importing FastAPI and creating the app instance

Defining the main endpoint with an asynchronous function

Returning JSON response with example data

Using uvicorn for running and auto-reloading the API

Testing the API using a local server

Explaining the reload flag for automatic updates

Creating a new endpoint for generating random numbers

Modifying the API to allow user-defined limits for random numbers

Handling multiple paths with identical names in the API

Automatic generation of API documentation with FastAPI

Using the 'docs' endpoint to access the API documentation

Creating a chatbot or other advanced projects using FastAPI

Incorporating machine learning or interacting with other APIs

Using the requests module for testing and interacting with the API

Stopping the server with control plus C for making persistent changes

Encouraging viewers to experiment and create their own APIs

Invitation for feedback on FastAPI and potential follow-up videos