4.51 out of 5
5739 reviews on Udemy

REST APIs with Flask and Python

Build professional REST APIs with Python, Flask, Flask-RESTful, and Flask-SQLAlchemy
Jose Salvatierra
32,401 students enrolled
English More
Connect web or mobile applications to databases and servers via REST APIs
Create secure and reliable REST APIs which include authentication, logging, caching, and more
Understand the different layers of a web server and how web applications interact with each other
Handle seamless user authentication with advanced features like token refresh
Handle log-outs and prevent abuse in your REST APIs with JWT blacklisting
Develop professional-grade REST APIs with expert instruction

Are you tired of boring, outdated, incomplete, or incorrect tutorials? I say no more to copy-pasting code that you don’t understand.

Welcome to one of the best resources online on creating REST APIs. I’m Jose, and I’m a software engineer; here to help you truly understand and develop your skills in web and REST API development with Python.

Production-ready REST APIs

This course will guide you in creating simple, intermediate, and advanced REST APIs including authentication, deployments, caching, and much more.

We’ll start with a Python refresher that will take you from the very basics to some of the most advanced features of Python—for you to never be lost or confused.

Using Flask and popular extensions Flask-RESTful, Flask-JWT, and Flask-SQLAlchemy we will dive right into developing complete, solid, production-ready REST APIs.

We will also look into essential technologies Git, Heroku, and nginx.

You’ll be able to…

  • Create resource-based, production-ready REST APIs using Flask and popular extensions;

  • Using SQLAlchemy to easily and efficiently store resources to a database; and

  • Understand the complex intricacies of deployments and performance of REST APIs.

I pride myself in providing excellent support and feedback to every single student. I am always available to guide you personally, and answer questions for your benefit.

Don’t wait, and sign up today to take another step toward web services mastery!

I’ll see you on the inside.


How to take this course

This course is structured in a specific way to make it as easy as possible for you to get exactly what you want out of it.

This lecture looks at maximising your time's value by making the course as efficient as possible for you.

Before we get started: a self-assessment

A short set of questions for you to evaluate your Python knowledge, and determine where to start the course.

Python on Windows

Installing Python is very simple! Follow these steps and you'll be up and running in no time.

Python on Mac

Installing Python is very simple! Follow these steps and you'll be up and running in no time.

A Full Python Refresher

Introduction to this section

This is a short introductory video to this section. I'm really excited to guide you through this Python refresher course!

Access the code for this section here

This lecture has a link to all the Python code we'll write in this section. Use it to check your code as you write it, or to refresh your memory!

Variables in Python

Let's look at variables in Python. Variables are just names for values, which we can reuse and reset.

Python is a dynamic typed language, which means variables don't need be constrained to a specific type.

Solution to coding exercise: Variables

The solution to the "Variables" Python coding exercise.

Methods in Python

In this video, let's look at methods in Python by creating some examples. Creating methods is simple, you just need the one keyword: def.

Solution to coding exercise: Methods

The solution to the "Method" Python coding exercise.

Lists, tuples, and sets

In this lecture we look at three essential data structures in Python: lists, tuples, and sets.

A list is an ordered collection of items.

A tuple is an immutable ordered collection of items.

A set is an unordered collection of unique items.

List, tuple, and set operations

In this video we look at ways we can interact with lists, tuples and sets. We look at adding more items to a list and a set, and also at why we cannot add items to a tuple.

Advanced set operations

In this fascinating video, we look at advanced set operations: calculating items which are in two sets, or items which are in one set but not another.

Lists, tuples, and sets
Solution to coding exercise: Lists, tuples, sets

The solution to the "Lists, tuples, and sets" Python coding exercise.

Loops in Python

Loops allow us to repeat things over and over. This video explores two different types of loop in Python: for loop and while loop.

If statements

This video explores how to create programs which can change depending on some input. For example, we might ask the user if they want to continue or not.

This makes use of boolean comparisons, such as:

  • 1 == 1 (which is True)
  • 5 > 5 (which is False)

The boolean comparisons we have available in Python are many:

  • ==
  • !=
  • >, <, <=, >=
  • is
  • is not
  • in
  • not in
Flow control—loops and ifs
Solution to coding exercise: Flow control

The solution to the "Flow control" Python coding exercise.

A programming exercise for you

A short programming exercise for you! I always recommend coding along the videos, and now you have a chance to prove it.

Program away!

List comprehension

List comprehension is a relatively unique thing to Python.

It allows us to succinctly use a for loop inside a list to generate values. These values then end up in the list.

For example, [x for x in range(10)] generates a list [0, 1, 2, 3, 4, 5, 6, 7, 8, 9].


Dictionaries are an extremely useful thing in Python.

They are akin to sets, but instead of being a set of unique values, they are a set of unique keys, and each has a value associated with it.

Are dictionaries "things"?

A rather philosophical question! An introduction to how we might shift our way of thinking, from data only, to things and objects.

Dictionaries and students
Solution to coding exercise: Dictionaries

The solution to the "Dictionaries and students" Python coding exercise.

Objects in Python

Objects are the natural progression from dictionaries. Instead of just holding data, objects hold another special type of data: methods.

A method is a function which operates on the object calling it. Thus, an object can use its own values to calculate outputs of methods. Very cool.

A Student example

This video looks at an example of Object-Oriented Programming by creating a Student class.

Classes and objects
Solution to coding exercise: Classes and objects

The solution to the "Classes and objects" Python coding exercise.

@classmethod and @staticmethod

In many instances, we don't want our methods to be solely referencing the object which calls them. Sometimes, we want to reference the class of the object. Other times, we don't need either the object or the class.

@classmethod and @staticmethod are two decorators (looking at that shortly!) which extend the capabilities of methods.

@classmethod and @staticmethod
Solution to coding exercise: @classmethod and @staticmethod

The solution to the "@classmethod and @staticmethod" Python coding exercise.

Inheritance in Object-Oriented Programming

Classes in Python can also inherit from one another. This essentially means that a class contains all of the properties and methods of the class it inherits from—but with the added bonus that it can have more.

*args and **kwargs

*args and **kwargs are truly fascinatingly confusing. For eons, they have annoyed Python learners.

To this I say no more!

They're just a way of passing arguments.

Passing functions as arguments

Not only we can pass values from one method to another, but we can also pass functions.

This is not used very often, but it can sometimes yield very powerful methods in very few lines of code.

Decorators in Python

One of the most confusing aspects of Python for learners is the concept of decorators.

These are things we can place on top of function definitions which allow us to extend the function by executing code before and after the function.

They are extremely powerful when used well!

Advanced decorators

In this video we look at advanced decorators in Python, which is decorators that take arguments.

This amplifies the decorator's usefulness, although also makes them slightly more contrived.

Conclusion of this section

This Python refresher course was great fun! In this conclusive lecture, we get ready to move onto bigger and better things.

Your first REST API

Introduction to this section

In this introductory video, we look at what we'll learn: all about the web. Using Flask, we can create our first web server application.

What is an API?

What is an API? How do you interact with them? What's the difference between a client and a provider?

Answers to all these questions are in this short lecture and the linked blog post!

Installing Flask

Installing Flask is a necessary first step. Fortunately, installing things in Python is really simple.

All we have to do is execute pip3.5 install Flask, and that will use the Python Package Index to download the package and install it for us.

Access the code for this section here

This lecture has a link to all the Python code we'll write in this section. Use it to check your code as you write it, or to refresh your memory!

Your first Flask application

Already we can create our first web server application! This is an application that returns some data when called using a GET request (such as through a web browser).

HTTP Verbs

In this lecture we look at how HTTP works and what the verbs mean. They're going to be extremely important when we come to think of REST APIs.

REST Principles

In this lecture we look at the principles behind REST.

REST APIs are only APIs that follow and comply with the REST principles.

Two of the main REST principles are:

  • That it is resource-based
  • That it is stateless
Creating our application endpoints

Now that we know about HTTP and REST, we can create our application endpoints (the routes), so we can return different data depending on which endpoint is called.

Returning a list of stores

In this video we extend the application by returning a list of stores.

Implementing other endpoints

In this video we implement the other missing endpoints in the application. We now have a complete web server application!

Calling the API from JavaScript

Although the focus of the course is not on creating applications to interact with our API, it's useful to know how the API will be called from within a web application.

Normally, APIs are called to retrieve data to create elements on a page, or to do things like authentication, saving to database, or delegate processing to the server.

Using Postman for API testing

Testing your API is essential. Without testing, you cannot be sure that your API works. Therefore, you cannot tell your users to use your API! What if it breaks?

In this video we look at Postman, a great tool to test APIs.

Conclusion of this section

In this section we have learned about the web and using Flask to create our first web server application. Next, on to creating compliant REST APIs!

Flask-RESTful for more efficient development

Welcome to this section

This is one of the main sections of the course. In this section we will look at more advanced Python concepts, create a more complex application, and learn about Flask-RESTful—a key Flask extension when creating REST APIs.

Virtualenvs and setting up Flask-RESTful

A very nice piece of software that we can use with Python is the virtualenv.

This allows us to have a different Python installation for every project, which means no shared libraries and context.

This is nice because libraries evolve over time. Something that worked in Flask-RESTful a year ago may not work today, so it makes sense to keep each project separate.

Or else, if we created a project last year and today we update Flask-RESTful, things may not work as expected!

Access the code for this section here

This lecture has a link to all the Python code we'll write in this section. Use it to check your code as you write it, or to refresh your memory!

Your first Flask-RESTful app

In this video we create our first Flask-RESTful app, which includes our first Resource (remember REST APIs work with resources, instead of just data?).

Test-first API design—what is that?

In this video we explore the concept of test-first API design—akin to Test Driven Development.

It's important to first understand what we want our API to do, before we start writing any code. After all, it's easy to get bogged down on technical details and forget to actually write things that we want to use!

Creating our Item Resource

In this video we create our Item resource, which represents the actions we can perform on a store item.

The ItemList and creating Items

In this video we look at the ItemList, which represents the actions we can perform on a collection of items; and also at creating items and putting them in an in-memory database.

Improving code and error control

In this video we look at refactoring the code and making it better. This is extremely important in programming. Every now and then, stop and look at what you've written. Then, make it nicer without changing what it does.

This is a sure way of making sure your code is always readable and maintainable—which means you or other people will find it easy to work with and improve later on.

Authentication and logging in—part 1

Ah, a key focus of the course!

Authentication is something virtually every API needs in one way or another.

In this video we look at part 1 of authentication, which includes another Flask extension: Flask-JWT.

Authentication and logging in—part 2

Part 2 of the authentication videos. Here we complete the authentication process and test it with Postman.

DELETE to delete Items

In this video we implement the DELETE HTTP verb, which is very simple with Flask-RESTful.

Now we can delete items from our in-memory database.

PUT to create or update Items

In this video we implement the PUT HTTP verb. One of the key definitions of PUT is that it has to be idempotent.

To be idempotent means that if we call the same endpoint 5 times in a row, only the first call will exert a change in the server.

We can use it to create an item, or to update an item if it already exists.

Advanced request parsing with Flask-RESTful

Very often we want to limit the data we accept in our requests. Using reqparse it becomes very easy to do this, and it's built into Flask-RESTful!

Optimising our final code and request parsing

In this final video we look once again at our code, and making it nicer and more efficient.

Something that often works is to look at code duplication, and trying to remove duplication.

Conclusion of this section

In this conclusive video, we look at what we've learned: creating proper REST APIs using a very popular Flask extension.

Storing resources in a SQL database

Welcome to this section

In this introductory video we look at what we'll learn in this section. It will be very exciting: saving things to a persistent database.

Until now we have used in-memory databases, which meant that shutting down our app resulted in data loss. No more!

Setting up our project

In this short video we look at setting up our project for this section and installing the required libraries (which, to interact with a SQLite database, happens to be none!).

Access the code for this section here

This lecture has a link to all the Python code we'll write in this section. Use it to check your code as you write it, or to refresh your memory!

Running a SQLite database and interacting with it from Python

In this video we look at running a local SQLite database and interacting with it from our Python code.

Logging in and retrieving Users from a database

In this video we look at logging our users in by using sample data stored in our database.

This entails retrieving our user's data using SQL, which we can do by using a SELECT statement.

Signing up and writing Users to a database

In this video we look at signing our users up to our app by writing their details to a database. This includes creating a /register endpoint to handle the incoming data.

Preventing duplicate usernames when signing users up

In this video we take a quick look at preventing duplicate usernames—a good example of things you have to think about when doing API design.

Retrieving our Item resources from a database

In this video we look at retrieving items from a database. Similar to getting our users to log in, but this time accessing our items table.

Writing our Item resources to a database

Naturally, retrieving items only is not enough!

In this video we look at creating items and writing them to the database, which means that our API is now usable by other applications if they want to store and retrieve data from our database.

Deleting our Item resources from the database

In this video we look at implementing item deletion, which involves deleting the appropriate row from the table.

Warning: it's easy to delete all data from the table, so be careful!

Refactoring insertion of items

In this video we look at refactoring (improving) the code so that the insertion of items is not coupled to the endpoint responsible for inserting.

This will be essential for when the PUT method is implemented.

The PUT method with database interaction

In this video we look at implementing the PUT HTTP verb, and this entails either creating or updating an existing item.

Retrieving many items from the database

In this video, we retrieve a list of items from the database and also perform final Postman testing.

Everything works!

Advanced Flask-JWT Configuration

A great little PDF on advanced configuration, including modifying the authentication URL, key, and various handlers.

Conclusion of this section

In this conclusive video we recap what we have learned: all about saving to a local SQLite database using Python.

Simplifying storage with Flask-SQLAlchemy

Welcome to this section!

In this section, we will look at what an ORM (Object-Relational Mapping) is, and how it can simplify the process of interacting with a database.

Access the code for this section here

This lecture has a link to all the Python code we'll write in this section. Use it to check your code as you write it, or to refresh your memory!

Setting up this section's project

In this lecture we look at installing all the requirements and getting set up.

Improving the project structure and maintainability

In this lecture we start discussing Python packages, and how we can create them. We then move some files around to make the project more maintainable by logically grouping our files and classes.

Creating User and Item models

In this video we create User and Item models. We discuss the difference between a model and a resource, as this is essential in order to design our programs well.

Verifying the app works after our changes

In this video we quickly test using Postman that our refactoring has not broken the API! This is extremely important, as it is easy to forget to test and then end up with a bunch of untested changes.

If something breaks, you won't know where to start fixing it!

Advanced Postman: environments and tests

In this video we look at advanced Postman usage: tests and environments.

This is extremely useful as it quickly lets us re-use existing text with environment variables.

Tests allow us to quick gauge whether an endpoint call has been successful or not. For example, if it took too long, returned an incorrect error code, didn't return the appropriate values, etc...

Telling SQLAlchemy about our tables and columns

In this video we tell SQLAlchemy about our tables and columns, which includes defining the data types and primary key.

Implementing the ItemModel using SQLAlchemy

In this video we greatly simplify the ItemModel by using methods that SQLAlchemy gives us. We also look into the query builder, which is a key part of SQLAlchemy, and that allows us to easily build SQL queries just by using Python code.

Implementing the UserModel using SQLAlchemy

In this video we implement the UserModel, which also simplifies it greatly.

Easily displaying the ItemList resource with SQLAlchemy

In this video we massively simplify the ItemList resource by virtue of using SQLAlchemy.

Instead of a massive code spew, we can reduce our ItemList to a single line of concise and readable code.

You can view and review the lecture materials indefinitely, like an on-demand channel.
Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don't have an internet connection, some instructors also let their students download course lectures. That's up to the instructor though, so make sure you get on their good side!
4.5 out of 5
5739 Ratings

Detailed Rating

Stars 5
Stars 4
Stars 3
Stars 2
Stars 1
30-Day Money-Back Guarantee


15 hours on-demand video
20 articles
Full lifetime access
Access on mobile and TV
Certificate of Completion