In this tutorial, Iāll show you how to create APIs in Python with Flask in a few simple steps. Iāll demonstrate how to create GET and POST methods in a few minutes.
APIs play a pivotal role in the internet and modern information infrastructures. API, which stands for Application Programming Interface, encompasses a set of rules, protocols, and tools enabling software to communicate with each other. APIs facilitate structured and predefined interactions between two software systems, enabling them to exchange information or execute operations.
Consider this example: When you log in to your Medium account, youāre utilizing an API. Upon submitting the login form with your username and password, this information is swiftly transmitted to a server for validation. The server then verifies the credentials and sends back a response, granting you access upon successful validation. This exemplifies the functionality of an API.
There exist various types of APIs and multiple methods to implement them. Throughout this tutorial, Iāll guide you on constructing an API in Python using Flask, a widely used web framework for developing both websites and APIs. Specifically, weāll create both a GET and a POST API. If the concepts of GET and POST seem unclear at the moment, donāt worryāāāIāll provide detailed explanations later on.
Table of Contents:
- Why create an API with Python
- Flask for creating Python APIs
- GET API in Python using Flask
- POST API in Python using Flask
Why create an API withĀ Python
Weāve discussed the significance of APIs in the context of the internet, yet we havenāt delved into how to create one using Python. Python stands out as a widely recognized programming language renowned for its simplicity.
The syntax of Python is clear and readable, making it ideal for developing and maintaining diverse software projects, including the construction of APIs. Moreover, Python boasts an extensive and highly active community, a crucial factor contributing to its widespread adoption in various software projects.
Flask for creating PythonĀ APIs
Flask serves as a micro-framework designed for developing web applications in Python. It embodies the characteristics of being lightweight, fast, simple, and flexible. Leveraging Flask enables the creation of intricate web applications, such as APIs.
Written in Python, Flask relies on the WSGI tool, a protocol system for Python web applications, and Jinja2, a Python-based template engine.
One of the standout attributes of Flask lies in its simplicity and extensive customization possibilities. With just a few lines of code, you can establish an API endpoint (referred to as a URL hosting the API) and seamlessly integrate an HTML template.
In the following sections, Iāll walk you through constructing both a GET API and a POST API using Python with Flask, all within a concise code block.
Note: To begin, ensure Flask is installed using pip install flask
or conda install flask
if you are using the conda virtual environment manager.
GET API in Python usingĀ Flask
The GET method is a type of API that retrieves information from a source using the HyperText Transfer Protocol (HTTP). This method is utilized to send a request to a server where request parameters are available in the URL as queries. An example of a GET request:
https://api.example.com/data?key1=value1&key2=value2
You are sending a request to the server regarding ākey1ā with the value āvalue1ā and ākey2ā with the value āvalue2ā. Data and information are publicly available, and there is no necessity to send additional parameters to the server beyond those required for your query. For instance, credentials or certificates are unnecessary.
The GET method is also used when loading a website. In this section, weāll create a GET API in Python using Flask to return a simple HTML page.
Letās write the code! Save the following code as āapp.pyā:
from flask import Flask, jsonify, request
app = Flask(__name__)
@app.route('/')
def index():
return """
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Congratulations</title>
</head>
<body>
<div style="text-align: center; margin-top: 100px;">
<h1>Congratulations, this is your first API endpoint!</h1>
</div>
</body>
</html>
"""
if __name__ == '__main__':
app.run(debug=True)
Well, now simply launch the Flask application with the command flask run --app app
and go to the URL http://127.0.0.1:5000. You'll see your first GET API in Python using Flask:
This is a very simple case but should be informative. We refer to the URL where the API is operational as the āendpointā.
Letās try to build a slightly more complex example. We will create a GET endpoint where we can request data using query parameters. The data within our āserverā in theĀ .py file will be:
data = [
{"city": "Napoli", "country": "Italy"},
{"city": "Pisa", "country": "Italy"},
{"city": "Reykjavik", "country": "Iceland"},
{"city": "Akureyri", "country": "Iceland"}
]
Now, we will create a section of our site at ā/citiesā. Remember that the Flask app still needs to be running. (use the command flask run --app app).
from flask import Flask, jsonify, request
app = Flask(__name__)
# Dati forniti
data = [
{"city": "Napoli", "country": "Italy"},
{"city": "Pisa", "country": "Italy"},
{"city": "Reykjavik", "country": "Iceland"},
{"city": "Akureyri", "country": "Iceland"}
]
@app.route('/cities', methods=['GET'])
def get_cities():
return jsonify(data)
If you access this page, it will return all the cities from our dataset:
[
{
"city": "Napoli",
"country": "Italy"
},
{
"city": "Pisa",
"country": "Italy"
},
{
"city": "Reykjavik",
"country": "Iceland"
},
{
"city": "Akureyri",
"country": "Iceland"
}
]
What if we want to filter our data using parameters from the URL through a query? Well, weāll need to add a few lines to our code. Weāll implement simple logic using conditional statements in Python. Weāll accept parameters from the query as follows:
- Country
- City
- Both Country and City
- None of the above
Therefore, weāll create an if-then-else statement in this manner:
if city and country:
filtered_cities = [c for c in data if c['city'] == city and c['country'] == country]
return jsonify(filtered_cities)
elif city:
filtered_cities = [c for c in data if c['city'] == city]
return jsonify(filtered_cities)
elif country:
filtered_cities = [c for c in data if c['country'] == country]
return jsonify(filtered_cities)
else:
return jsonify(data)
In that code, we can handle all possible combinations. If we apply a filter, weāll receive the filtered data, otherwise, weāll still get filtered data.
The complete new code will be:
from flask import Flask, jsonify, request
app = Flask(__name__)
data = [
{"city": "Napoli", "country": "Italy"},
{"city": "Pisa", "country": "Italy"},
{"city": "Reykjavik", "country": "Iceland"},
{"city": "Akureyri", "country": "Iceland"}
]
@app.route('/cities', methods=['GET'])
def get_cities():
city = request.args.get('city')
country = request.args.get('country')
if city and country:
filtered_cities = [c for c in data if c['city'] == city and c['country'] == country]
return jsonify(filtered_cities)
elif city:
filtered_cities = [c for c in data if c['city'] == city]
return jsonify(filtered_cities)
elif country:
filtered_cities = [c for c in data if c['country'] == country]
return jsonify(filtered_cities)
else:
return jsonify(data)
if __name__ == '__main__':
app.run(debug=True)
Letās try an example: if we want to obtain an Italian city, we can use this URL: http://127.0.0.1:5000/cities?country=Italy
[
{
"city": "Napoli",
"country": "Italy"
},
{
"city": "Pisa",
"country": "Italy"
}
]
Great! But what if we want to input some data? To input user data, we canāt use the GET method. Until now, weāve fetched data from a server or a URL without sending data, except for the parameters. If we want to send data, weāll have to create a POST method.
POST API in Python usingĀ Flask
The POST method enables us to transmit information to a server. For instance, when we use a login form, we send our credentials to the server to verify their correctness and gain access to the service. This operation isnāt just about receiving data from the server; the user is also transmitting data to the server.
Consider this scenario: we want to add a new city to the dataset of cities on our website. How do we accomplish this? The answer lies in the POST method.
Letās explore how we can create a POST API in Python using Flask. We have the option of utilizing the same endpoint or creating a new one. Weāve opted for the former for convenience, but the choice of method doesnāt matter.
Below is the code to implement this:
@app.route('/cities', methods=['POST'])
def add_city():
new_city = request.json
if 'city' in new_city and 'country' in new_city:
data.append(new_city)
return jsonify({"message": "City added successfully", "city": new_city}), 201
else:
return jsonify({"error": "City and country are required fields"}), 400
We will send a JSON (a simple Python dictionary) containing our new data, and this endpoint will append the new data to our cities dataset and return a message with a code. By incorporating these lines into our previous code, our Python file will look like this:
from flask import Flask, jsonify, request
app = Flask(__name__)
# Dati forniti
data = [
{"city": "Napoli", "country": "Italy"},
{"city": "Pisa", "country": "Italy"},
{"city": "Reykjavik", "country": "Iceland"},
{"city": "Akureyri", "country": "Iceland"}
]
@app.route('/cities', methods=['GET'])
def get_cities():
return jsonify(data)
@app.route('/cities', methods=['POST'])
def add_city():
new_city = request.json
if 'city' in new_city and 'country' in new_city:
data.append(new_city)
return jsonify({"message": "City added successfully", "city": new_city}), 201
else:
return jsonify({"error": "City and country are required fields"}), 400
if __name__ == '__main__':
app.run(debug=True)
To send data using the POST method in Python, we need to execute several lines of code in a separate Python file. The code to execute a POST request in Python is as follows:
import requests
url = 'http://127.0.0.1:5000/cities'
data = {'city': 'Sevilla', 'country': 'Spain'}
x = requests.post(url, json = data)
print(x.text)
NB: Remember that the Flask app still needs to be running. (use the command flask run --app app).
Now, letās attempt a POST request by adding city = āSevillaā and country = āSpainā. Weāll observe the following output:
{
"city": {
"city": "Sevilla",
"country": "Spain"
},
"message": "City added successfully"
}
What happens if we now call our endpoint? Hereās the updated data:
[
{
"city": "Napoli",
"country": "Italy"
},
{
"city": "Pisa",
"country": "Italy"
},
{
"city": "Reykjavik",
"country": "Iceland"
},
{
"city": "Akureyri",
"country": "Iceland"
},
{
"city": "Sevilla",
"country": "Spain"
}
]
Excellent! Weāve successfully constructed a POST API in Python using Flask in just a few simple steps. Now, we can retrieve data from a URL or server using the GET method and also add new data using the POST method.
Final Thoughts
In this tutorial, Iāve demonstrated how to create APIs in Python using Flask. We discussed the significance of APIs in the web, why Python is a suitable choice for building them, and weāve explored the creation of both GET and POST APIs in Python using Flask.
For further exploration on this topic, I recommend checking out this inspiring article: How To Process Incoming Request Data in Flask.
If you found this article informative and helpful, please consider sharing it with your friends and colleagues. Stay updated with new articles and updates by visiting my Medium and LinkedIn profiles. Until the next article, happy coding!