This article demonstrates how to interact with a Flask REST API from a Python client using the requests library. The requests library simplifies the process of sending HTTP requests and handling responses in Python.
Step 1: Installing the requests Library
Before you can start consuming your Flask API, you need to ensure that the requests library is installed in your Python environment. Open your terminal or command prompt and execute the following command:
Bash
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | (env) C:\vscode-python-workspace>pip install requestsCollecting requestsDownloading requests-2.32.3-py3-none-any.whl.metadata (4.6 kB)Collecting charset-normalizer<4,>=2 (from requests)Downloading charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl.metadata (36 kB)Collecting idna<4,>=2.5 (from requests)Downloading idna-3.10-py3-none-any.whl.metadata (10 kB)Collecting urllib3<3,>=1.21.1 (from requests)Downloading urllib3-2.3.0-py3-none-any.whl.metadata (6.5 kB)Collecting certifi>=2017.4.17 (from requests)Downloading certifi-2025.1.31-py3-none-any.whl.metadata (2.5 kB)Downloading requests-2.32.3-py3-none-any.whl (64 kB)Downloading certifi-2025.1.31-py3-none-any.whl (166 kB)Downloading charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl (102 kB)Downloading idna-3.10-py3-none-any.whl (70 kB)Downloading urllib3-2.3.0-py3-none-any.whl (128 kB)Installing collected packages: urllib3, idna, charset-normalizer, certifi, requestsSuccessfully installed certifi-2025.1.31 charset-normalizer-3.4.1 idna-3.10 requests-2.32.3 urllib3-2.3.0(env) C:\vscode-python-workspace> |
This command will download and install the requests library and its dependencies in your active Python environment.
Step 2: Creating the Client Script (flaskrestgetcall.py)
Create a new Python file named flaskrestgetcall.py and add the following code:
Python
import requests
def consume_flask_api(url, method=’GET’, data=None, headers=None):
“””
Consumes a Flask API endpoint.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | Args: url (str): The URL of the API endpoint. method (str): The HTTP method (GET, POST, PUT, DELETE, etc.). Defaults to 'GET'. data (dict): The data to send in the request body (for POST, PUT, etc.). Defaults to None. headers (dict): Custom headers to include in the request. Defaults to None.Returns: dict or None: The JSON response from the API, or None if an error occurs."""try: if method == 'GET': response = requests.get(url, headers=headers) elif method == 'POST': response = requests.post(url, json=data, headers=headers) # Send data as JSON elif method == 'PUT': response = requests.put(url, json=data, headers=headers) elif method == 'DELETE': response = requests.delete(url, headers=headers) # Add other HTTP methods as needed response.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx) return response.json() # Parse and return the JSON responseexcept requests.exceptions.RequestException as e: print(f"Error consuming API: {e}") if response is not None: print(f"Response status code: {response.status_code}") try: print(f"Response text: {response.text}") except: print("Response text could not be obtained.") return None |
Example usage (assuming your Flask API is running at http://127.0.0.1:5000)
api_url = “http://127.0.0.1:5000/api/data” # Replace with your API endpoint URL
Example 1: GET request
result = consume_flask_api(api_url)
if result:
print(“GET Response:”, result)
Example 2: POST request (if your API supports POST)
post_data = {“key”: “value”, “another_key”: 123} # example data
post_url = “http://127.0.0.1:5000/api/post_endpoint” #replace with your post endpoint
post_result = consume_flask_api(post_url, method=’POST’, data=post_data)
if post_result:
print(“POST Response:”, post_result)
Example 3: Adding Headers
headers = {“Content-Type”: “application/json”, “Authorization”: “Bearer your_token_here”}
result_with_headers = consume_flask_api(api_url, headers=headers)
if result_with_headers:
print(“GET Response with Headers:”, result_with_headers)
This script defines a function consume_flask_api that takes the API URL, HTTP method, optional data, and headers as arguments. It uses the requests library to make the API call and handles potential errors. The script also includes example usage for making GET and POST requests, as well as demonstrating how to include custom headers.
Step 3: Debugging the Client Application
To effectively debug your client application while interacting with the Flask API, follow these steps:
Start the Flask Server in Debug Mode: Ensure your Flask API server is running in debug mode. This will provide more detailed error messages and allow for easier inspection of the server-side behavior. Typically, you would run your Flask application with a configuration that enables debugging (e.g., app.debug = True or by setting an environment variable). Verify that your API endpoints are functioning correctly by accessing them directly through a browser or a tool like Postman.
Configure the Client Request File for Debugging: You can use standard Python debugging techniques within your flaskrestgetcall.py file. This involves setting breakpoints at strategic locations in your code to examine the flow of execution and the values of variables.
Inspecting Request Parameters (Lines I21-I24): Place breakpoints before the requests.get(), requests.post(), etc., calls within the consume_flask_api function. This will allow you to inspect the values of url, method, data, and headers just before the request is sent. Ensure these parameters are constructed correctly.
Examining the Response Object (Lines I28-I31): Set breakpoints after the API call (response = requests.get(…)) to inspect the response object. Key attributes to examine include:
response.status_code: Verify that the HTTP status code indicates success (e.g., 200 OK).
response.headers: Check the response headers, particularly the Content-Type to ensure it matches the expected format (e.g., application/json).
response.text: Inspect the raw response content, which can be helpful if there are issues with JSON parsing.
response.json(): If you expect a JSON response, examine the parsed JSON data. Handle potential json.JSONDecodeError exceptions if the response is not valid JSON.
By strategically placing breakpoints and inspecting the request and response details, you can effectively pinpoint issues in your client-side code and understand how it interacts with your Flask API. Remember to replace the example API URLs in the flaskrestgetcall.py script with the actual endpoints of your Flask API.
Code can be found on below url on github
