A Complete Code Tutorial To Working With APIs In Flask

In this post, I want to show you how to quickly put together a complete REST API using Flask. As you might know, Flask is a perfect fit for the job!

Our example creates a movies API but you can follow this for any API you want to create!

An API needs a data source, a URL scheme, and request methods that clients use to access resources.

To keep things simple and focused on the API, we skip setting up a database and use an in-memory array to hold our movies. This allows us to focus on the API request methods.

We set up our API code in a new Python file called 

from flask import (
    Flask,
    url_for,
    request,
    render_template,
    jsonify,
    abort,
    make_response,
)

# Create Flask application
app = Flask(__name__)

# This stores our movies
movies = [
    {
        "id": 1,
        "title": "The Shawshank Redemption",
        "plot": """Two imprisoned men bond over a 
        number of years, finding solace and 
        eventual redemption through acts 
        of common decency.""",
        "director": "Frank Darabont",
        "starring": [
            "Tim Robbins",
            "Morgan Freeman",
            "Bob Gunton",
        ],
        "genre": "Drama",
        "year": "1994",
    },
    {
        "id": 2,
        "title": "The Dark Knight",
        ...

Our first API route handles listing all movies. Here is the code that does this.

# Returns a list with all movies
@app.route("/api/v1.0/movies", methods=["GET"])
def get_movies():
    return jsonify({"movies": movies})

 from our data store. When using a database like MySQL or MongoDB, this is where you would integrate database calls to fetch movie data. 

Here is how you implement retrieving a single movie.

# Get movie by id
@app.route(
    "/api/v1.0/movies/<int:id>", methods=["GET"]
)
def get_movie(id):
    data = [
        movie
        for movie in movies
        if movie["id"] == id
    ]
    if len(data) == 0:
        abort(404)
    return jsonify({"movie": data[0]})

 in the URL. If one is found, we send it back, using 

When creating a new movie, a REST client sends the new movie's attributes in a JSON payload. It might look as shown in the image.

Here is the method in our app that takes this payload and creates new movies.

# Add new movie
@app.route("/api/v1.0/movies", methods=["POST"])
def add_movie():
    if (
        not request.json
        or not "title" in request.json
    ):
        abort(400)

    # Substitute empty strings 
    # ...for missing attributes    
    movie = {
        "id": movies[-1]["id"] + 1,
        "title": request.json["title"],
        "plot": request.json.get("plot", ""),
        "director": request.json.get(
            "director", ""
        ),
        "genre": request.json.get("genre", ""),
        "starring": request.json.get(
            "starring", ""
        ),
        "year": request.json.get("year", ""),
    }
    movies.append(movie)
    return jsonify({"movie": movie})

In this method, we first check if the user supplied a 

Otherwise, we create a new movie with the supplied 

, and other attributes. We save it in the 

Our method here is also the most complex in this example. That's because it has to handle multiple moving parts.

# Update existing movie
@app.route(
    "/api/v1.0/movies/<int:id>", methods=["PUT"]
)
def update_movie(id):
    data = [
        movie
        for movie in movies
        if movie["id"] == id
    ]
    if len(data) == 0:
        abort(404)
    if not request.json:
        abort(400)
    if (
        "title" in request.json
        and type(request.json["title"]) is not str
    ):
        abort(400)
    if (
        "plot" in request.json
        and type(request.json["plot"]) is not str
    ):
        abort(400)

    # Update movie attribute e.g. `title` with
    # ...new attribute value from request
    # ...if request does not have an updated value
    # ...reuse the existing value for the attribute
    data[0]["title"] = request.json.get(
        "title", data[0]["title"]
    )
    data[0]["plot"] = request.json.get(
        "plot", data[0]["plot"]
    )
    data[0]["director"] = request.json.get(
        "director", data[0]["director"]
    )
    data[0]["starring"] = request.json.get(
        "starring", data[0]["starring"]
    )
    data[0]["genre"] = request.json.get(
        "genre", data[0]["genre"]
    )
    data[0]["year"] = request.json.get(
        "year", data[0]["year"]
    )
    return jsonify({"movie": data[0]})

 the request. We do the same if the user has not supplied a 

, or if the user has not supplied any valid 

. If an attribute is not supplied in the 

The API is almost complete! Here's the code that handles delete requests.

# Delete movie
@app.route(
    "/api/v1.0/movies/<int:id>",
    methods=["DELETE"],
)
def delete_movie(id):
    data = [
        movie
        for movie in movies
        if movie["id"] == id
    ]
    if len(data) == 0:
        abort(404)
    movies.remove(data[0])
    return jsonify({"result": True})

 in the URL. If a match is not found, we 

 where we've focused on building a whole, master-level SaaS app end to end.

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Tutorials on Flask

A Complete Code Tutorial To Working With APIs In Flask

Email Newsletter

Popular Topics

Masterclasses

Tutorials

Fullstack React with TypeScript