Make HTTP Requests with the Python urllib and requests Modules

Click to share! ⬇️

In today’s interconnected world, working with APIs and web services has become an essential skill for developers. The ability to make HTTP requests allows you to communicate with various web services and fetch data for your applications. Python, being a versatile and powerful programming language, provides several modules to help you achieve this task effortlessly.

How To Install and Import the Python urllib and requests Modules
How To Make a Simple HTTP GET Request with urllib
How To Make a Simple HTTP GET Request with requests
How To Add Headers to Your HTTP Requests in urllib
How To Add Headers to Your HTTP Requests in requests
How To Make HTTP POST Requests with urllib
How To Make HTTP POST Requests with requests
How To Handle HTTP Errors and Exceptions with urllib
How To Handle HTTP Errors and Exceptions with requests
How To Work with JSON Data using urllib and requests
How To Authenticate Your HTTP Requests with urllib
How To Authenticate Your HTTP Requests with requests
Summary

This tutorial will focus on two widely-used Python modules for making HTTP requests: urllib and requests. While urllib is a built-in module that comes with Python’s standard library, requests is a popular third-party module that offers a more user-friendly and convenient interface for making HTTP requests.

In this guide, we will walk you through the installation and usage of both modules, covering topics such as making GET and POST requests, adding headers, handling errors and exceptions, working with JSON data, and authenticating your requests. By the end of this tutorial, you will have a solid understanding of how to make HTTP requests using the Python urllib and requests modules, equipping you with the knowledge to interact with APIs and web services in your projects.

How To Install and Import the Python urllib and requests Modules

Before we dive into making HTTP requests, let’s first set up our Python environment by installing the necessary modules and importing them into our script.

Step 1: Install the requests module

While the urllib module comes built-in with Python, the requests module needs to be installed separately. You can install it using the pip package manager. Open your terminal or command prompt and run the following command:

pip install requests

This command will download and install the requests module and its dependencies.

Step 2: Import the urllib module

To use the urllib module in your Python script, you need to import it first. The urllib module consists of several submodules, but we will primarily focus on urllib.request and urllib.parse. Add the following lines to your Python script to import these submodules:

import urllib.request
import urllib.parse

Step 3: Import the requests module

Similarly, you need to import the requests module in your Python script to use its functionality. Simply add the following line to your script:

import requests

Now that you have installed and imported the necessary modules, you are ready to start making HTTP requests using Python’s urllib and requests modules. In the following sections, we will explore various aspects of making HTTP requests, such as making GET and POST requests, adding headers, handling errors and exceptions, and more.

How To Make a Simple HTTP GET Request with urllib

An HTTP GET request is a method used to retrieve information from a specified resource. In this section, we will learn how to make a simple HTTP GET request using the urllib module.

Here’s a step-by-step guide:

Step 1: Specify the URL

First, you need to specify the URL of the resource you want to access. Store it in a variable for easy reference:

url = "https://api.example.com/data"

Step 2: Make the GET request

Use the urlopen() function from the urllib.request submodule to make the GET request. This function takes the URL as its argument and returns a response object:

response = urllib.request.urlopen(url)

Step 3: Read the response

The response object contains the data returned from the server. You can read the response data by calling the read() method on the response object:

response_data = response.read()

The read() method returns the data as bytes. To convert it to a string, you can use the decode() method:

response_data_str = response_data.decode('utf-8')

Step 4: Close the connection

After reading the response data, it’s important to close the connection to free up resources. You can do this by calling the close() method on the response object:

response.close()

Complete Example:

Here’s the complete example of making a simple HTTP GET request with the urllib module:

import urllib.request

url = "https://api.example.com/data"
response = urllib.request.urlopen(url)
response_data = response.read()
response_data_str = response_data.decode('utf-8')
response.close()

print(response_data_str)

This script will make an HTTP GET request to the specified URL, read the response data, and print it as a string.

How To Make a Simple HTTP GET Request with requests

The requests module offers a more user-friendly and convenient interface for making HTTP requests. In this section, we will learn how to make a simple HTTP GET request using the requests module.

Here’s a step-by-step guide:

Step 1: Specify the URL

First, you need to specify the URL of the resource you want to access. Store it in a variable for easy reference:

url = "https://api.example.com/data"

Step 2: Make the GET request

Use the get() function from the requests module to make the GET request. This function takes the URL as its argument and returns a response object:

response = requests.get(url)

Step 3: Read the response

The response object contains the data returned from the server. You can access the response data as a text string directly using the text attribute of the response object:

response_data_str = response.text

Complete Example:

Here’s the complete example of making a simple HTTP GET request with the requests module:

import requests

url = "https://api.example.com/data"
response = requests.get(url)
response_data_str = response.text

print(response_data_str)

This script will make an HTTP GET request to the specified URL and print the response data as a string. The requests module automatically handles connection management, so there is no need to manually close the connection like in the urllib module.

How To Add Headers to Your HTTP Requests in urllib

Headers are an important part of HTTP requests, as they provide additional information to the server about the client and the request being made. In this section, we will learn how to add headers to your HTTP requests using the urllib module.

Here’s a step-by-step guide:

Step 1: Specify the URL

First, you need to specify the URL of the resource you want to access. Store it in a variable for easy reference:

url = "https://api.example.com/data"

Step 2: Create a custom header

Create a dictionary containing the header fields and their values. For example, you can add a custom User-Agent header like this:

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.3",
    "Accept": "application/json"
}

Step 3: Create a Request object

Instead of directly using the urlopen() function, you can create a Request object that allows you to add custom headers. Import the Request class from the urllib.request submodule and create an instance with the specified URL and headers:

from urllib.request import Request

req = Request(url, headers=headers)

Step 4: Make the GET request

Use the urlopen() function with the Request object to make the GET request:

response = urllib.request.urlopen(req)

Step 5: Read and decode the response

Read the response data and decode it using the read() and decode() methods:

response_data = response.read()
response_data_str = response_data.decode('utf-8')

Step 6: Close the connection

Close the connection by calling the close() method on the response object:

response.close()

Complete Example:

Here’s the complete example of adding headers to an HTTP GET request with the urllib module:

import urllib.request
from urllib.request import Request

url = "https://api.example.com/data"
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.3",
    "Accept": "application/json"
}

req = Request(url, headers=headers)
response = urllib.request.urlopen(req)
response_data = response.read()
response_data_str = response_data.decode('utf-8')
response.close()

print(response_data_str)

This script will make an HTTP GET request to the specified URL with the added custom headers, read the response data, and print it as a string.

How To Add Headers to Your HTTP Requests in requests

Adding headers to your HTTP requests using the requests module is quite simple and straightforward. In this section, we will learn how to add headers to your HTTP requests with the requests module.

Here’s a step-by-step guide:

Step 1: Specify the URL

First, you need to specify the URL of the resource you want to access. Store it in a variable for easy reference:

url = "https://api.example.com/data"

Step 2: Create a custom header

Create a dictionary containing the header fields and their values. For example, you can add a custom User-Agent header like this:

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.3",
    "Accept": "application/json"
}

Step 3: Make the GET request with custom headers

Use the get() function from the requests module to make the GET request. Pass the URL as the first argument and the headers dictionary as the headers keyword argument:

response = requests.get(url, headers=headers)

Step 4: Read the response

You can access the response data as a text string directly using the text attribute of the response object:

response_data_str = response.text

Complete Example:

Here’s the complete example of adding headers to an HTTP GET request with the requests module:

import requests

url = "https://api.example.com/data"
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.3",
    "Accept": "application/json"
}

response = requests.get(url, headers=headers)
response_data_str = response.text

print(response_data_str)

This script will make an HTTP GET request to the specified URL with the added custom headers and print the response data as a string. The requests module automatically handles connection management, so there is no need to manually close the connection like in the urllib module.

How To Make HTTP POST Requests with urllib

HTTP POST requests are used to send data to a server to create or update a resource. In this section, we will learn how to make HTTP POST requests using the urllib module.

Here’s a step-by-step guide:

Step 1: Specify the URL

First, you need to specify the URL of the resource you want to send data to. Store it in a variable for easy reference:

url = "https://api.example.com/data"

Step 2: Prepare the data

Create a dictionary containing the data you want to send in the POST request. For example:

data = {
    "name": "John Doe",
    "email": "john.doe@example.com"
}

Step 3: Convert the data to a URL-encoded format

The data needs to be converted to a URL-encoded format before sending it in a POST request. Use the urlencode() function from the urllib.parse submodule to convert the dictionary to a URL-encoded string:

data_encoded = urllib.parse.urlencode(data)

Step 4: Convert the URL-encoded data to bytes

The URL-encoded data needs to be converted to bytes before it can be sent in a POST request. Use the encode() method to convert the URL-encoded string to bytes:

data_bytes = data_encoded.encode('utf-8')

Step 5: Make the POST request

Use the urlopen() function from the urllib.request submodule to make the POST request. Pass the URL as the first argument and the data bytes as the data keyword argument:

response = urllib.request.urlopen(url, data=data_bytes)

Step 6: Read and decode the response

Read the response data and decode it using the read() and decode() methods:

response_data = response.read()
response_data_str = response_data.decode('utf-8')

Step 7: Close the connection

Close the connection by calling the close() method on the response object:

response.close()

Complete Example:

Here’s the complete example of making an HTTP POST request with the urllib module:

import urllib.request
import urllib.parse

url = "https://api.example.com/data"
data = {
    "name": "John Doe",
    "email": "john.doe@example.com"
}

data_encoded = urllib.parse.urlencode(data)
data_bytes = data_encoded.encode('utf-8')

response = urllib.request.urlopen(url, data=data_bytes)
response_data = response.read()
response_data_str = response_data.decode('utf-8')
response.close()

print(response_data_str)

This script will make an HTTP POST request to the specified URL, send the data, read the response data, and print it as a string.

How To Make HTTP POST Requests with requests

Making HTTP POST requests with the requests module is quite simple and straightforward. In this section, we will learn how to make HTTP POST requests using the requests module.

Here’s a step-by-step guide:

Step 1: Specify the URL

First, you need to specify the URL of the resource you want to send data to. Store it in a variable for easy reference:

url = "https://api.example.com/data"

Step 2: Prepare the data

Create a dictionary containing the data you want to send in the POST request. For example:

data = {
    "name": "John Doe",
    "email": "john.doe@example.com"
}

Step 3: Make the POST request

Use the post() function from the requests module to make the POST request. Pass the URL as the first argument and the data dictionary as the data keyword argument:

response = requests.post(url, data=data)

Step 4: Read the response

You can access the response data as a text string directly using the text attribute of the response object:

response_data_str = response.text

Complete Example:

Here’s the complete example of making an HTTP POST request with the requests module:

import requests

url = "https://api.example.com/data"
data = {
    "name": "John Doe",
    "email": "john.doe@example.com"
}

response = requests.post(url, data=data)
response_data_str = response.text

print(response_data_str)

This script will make an HTTP POST request to the specified URL, send the data, and print the response data as a string. The requests module automatically handles connection management, so there is no need to manually close the connection like in the urllib module.

How To Handle HTTP Errors and Exceptions with urllib

When making HTTP requests using the urllib module, you may encounter errors and exceptions such as network issues, invalid URLs, or HTTP status errors (e.g., 404 Not Found). In this section, we will learn how to handle HTTP errors and exceptions with the urllib module.

Here’s a step-by-step guide:

Step 1: Import required modules and classes

First, you need to import the required modules and classes. Import the urllib.request, urllib.error, and urllib.parse modules:

import urllib.request
import urllib.error
import urllib.parse

Step 2: Make the request in a try-except block

Enclose the HTTP request code in a try-except block to catch any errors or exceptions that may occur during the request:

url = "https://api.example.com/data"

try:
    response = urllib.request.urlopen(url)
except urllib.error.HTTPError as e:
    print(f"An HTTP error occurred: {e}")
except urllib.error.URLError as e:
    print(f"A URL error occurred: {e}")
else:
    # Continue processing the response if no errors occurred
    response_data = response.read()
    response_data_str = response_data.decode('utf-8')
    response.close()
    print(response_data_str)

In this example, we handle two types of errors:

urllib.error.HTTPError: This exception is raised when the server returns an HTTP error status code (e.g., 404 Not Found or 500 Internal Server Error).
urllib.error.URLError: This exception is raised when there’s a problem with the URL or network connection (e.g., invalid URL or network issue).

Complete Example:

Here’s the complete example of handling HTTP errors and exceptions with the urllib module:

import urllib.request
import urllib.error
import urllib.parse

url = "https://api.example.com/data"

try:
    response = urllib.request.urlopen(url)
except urllib.error.HTTPError as e:
    print(f"An HTTP error occurred: {e}")
except urllib.error.URLError as e:
    print(f"A URL error occurred: {e}")
else:
    # Continue processing the response if no errors occurred
    response_data = response.read()
    response_data_str = response_data.decode('utf-8')
    response.close()
    print(response_data_str)

This script will make an HTTP request to the specified URL and handle any HTTP errors or exceptions that may occur. If no errors are encountered, it will print the response data as a string.

How To Handle HTTP Errors and Exceptions with requests

When making HTTP requests using the requests module, you may encounter errors and exceptions such as network issues, invalid URLs, or HTTP status errors (e.g., 404 Not Found). In this section, we will learn how to handle HTTP errors and exceptions with the requests module.

Here’s a step-by-step guide:

Step 1: Import the required module

First, you need to import the required module. Import the requests module:

import requests

Step 2: Make the request in a try-except block

Enclose the HTTP request code in a try-except block to catch any errors or exceptions that may occur during the request:

url = "https://api.example.com/data"

try:
    response = requests.get(url)
    response.raise_for_status()
except requests.exceptions.HTTPError as e:
    print(f"An HTTP error occurred: {e}")
except requests.exceptions.RequestException as e:
    print(f"A request error occurred: {e}")
else:
    # Continue processing the response if no errors occurred
    response_data_str = response.text
    print(response_data_str)

In this example, we handle two types of errors:

requests.exceptions.HTTPError: This exception is raised when the server returns an HTTP error status code (e.g., 404 Not Found or 500 Internal Server Error). The raise_for_status() method will raise this exception if the HTTP status code indicates an error.
requests.exceptions.RequestException: This is a base class for all requests exceptions. Catching this exception will handle all other request-related exceptions, such as network issues or invalid URLs.

Complete Example:

Here’s the complete example of handling HTTP errors and exceptions with the requests module:

import requests

url = "https://api.example.com/data"

try:
    response = requests.get(url)
    response.raise_for_status()
except requests.exceptions.HTTPError as e:
    print(f"An HTTP error occurred: {e}")
except requests.exceptions.RequestException as e:
    print(f"A request error occurred: {e}")
else:
    # Continue processing the response if no errors occurred
    response_data_str = response.text
    print(response_data_str)

This script will make an HTTP request to the specified URL and handle any HTTP errors or exceptions that may occur. If no errors are encountered, it will print the response data as a string.

How To Work with JSON Data using urllib and requests

JSON (JavaScript Object Notation) is a lightweight data interchange format commonly used in API responses. In this section, we will learn how to work with JSON data using both the urllib and requests modules.

Working with JSON Data using urllib

Step 1: Import required modules and classes

First, import the required modules and classes. Import the urllib.request, urllib.error, urllib.parse, and json modules:

import urllib.request
import urllib.error
import urllib.parse
import json

Step 2: Make the request and decode the JSON response

Make the HTTP request, read the response data, and decode it using the json.loads() function:

url = "https://api.example.com/data"

try:
    response = urllib.request.urlopen(url)
    response_data = response.read()
    response_data_str = response_data.decode('utf-8')
    response_json = json.loads(response_data_str)
except urllib.error.HTTPError as e:
    print(f"An HTTP error occurred: {e}")
except urllib.error.URLError as e:
    print(f"A URL error occurred: {e}")
else:
    # Continue processing the JSON data if no errors occurred
    print(response_json)

response.close()

Working with JSON Data using requests

Step 1: Import the required module

First, import the required module. Import the requests module:

import requests

Step 2: Make the request and decode the JSON response

Make the HTTP request and decode the JSON response using the json() method of the response object:

url = "https://api.example.com/data"

try:
    response = requests.get(url)
    response.raise_for_status()
    response_json = response.json()
except requests.exceptions.HTTPError as e:
    print(f"An HTTP error occurred: {e}")
except requests.exceptions.RequestException as e:
    print(f"A request error occurred: {e}")
else:
    # Continue processing the JSON data if no errors occurred
    print(response_json)

In both examples, the JSON data is stored in the response_json variable, which you can use to access and manipulate the JSON data. The main difference between the two approaches is that the urllib approach requires manual decoding of the response data, while the requests approach provides a convenient json() method to decode the JSON data automatically.

How To Authenticate Your HTTP Requests with urllib

Many APIs and web services require authentication to access protected resources. In this section, we will learn how to authenticate your HTTP requests using the urllib module.

Here’s a step-by-step guide for basic authentication:

Step 1: Import required modules and classes

First, import the required modules and classes. Import the urllib.request, urllib.error, and urllib.parse modules, as well as the HTTPBasicAuthHandler and HTTPPasswordMgrWithDefaultRealm classes:

import urllib.request
import urllib.error
import urllib.parse
from urllib.request import HTTPBasicAuthHandler, HTTPPasswordMgrWithDefaultRealm

Step 2: Create an instance of HTTPPasswordMgrWithDefaultRealm

Create an instance of the HTTPPasswordMgrWithDefaultRealm class, which will store your username and password:

password_mgr = HTTPPasswordMgrWithDefaultRealm()

Step 3: Add your username and password

Call the add_password() method on the password manager object to add your username and password for a specific URL or domain:

url = "https://api.example.com/data"
username = "your_username"
password = "your_password"

password_mgr.add_password(None, url, username, password)

Step 4: Create an instance of HTTPBasicAuthHandler

Create an instance of the HTTPBasicAuthHandler class and pass the password manager object as an argument:

auth_handler = HTTPBasicAuthHandler(password_mgr)

Step 5: Build and install the opener

Create an opener that uses the authentication handler and install it globally with urllib.request.install_opener():

opener = urllib.request.build_opener(auth_handler)
urllib.request.install_opener(opener)

Step 6: Make the authenticated request

Now that the authentication handler is installed, you can make authenticated requests using urllib.request.urlopen():

try:
    response = urllib.request.urlopen(url)
    response_data = response.read()
    response_data_str = response_data.decode('utf-8')
except urllib.error.HTTPError as e:
    print(f"An HTTP error occurred: {e}")
except urllib.error.URLError as e:
    print(f"A URL error occurred: {e}")
else:
    print(response_data_str)
    response.close()

Complete Example:

Here’s the complete example of authenticating HTTP requests with the urllib module:

import urllib.request
import urllib.error
import urllib.parse
from urllib.request import HTTPBasicAuthHandler, HTTPPasswordMgrWithDefaultRealm

url = "https://api.example.com/data"
username = "your_username"
password = "your_password"

password_mgr = HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, url, username, password)

auth_handler = HTTPBasicAuthHandler(password_mgr)

opener = urllib.request.build_opener(auth_handler)
urllib.request.install_opener(opener)

try:
    response = urllib.request.urlopen(url)
    response_data = response.read()
    response_data_str = response_data.decode('utf-8')
except urllib.error.HTTPError as e:
    print(f"An HTTP error occurred: {e}")
except urllib.error.URLError as e:
    print(f"A URL error occurred: {e}")
else:
    print(response_data_str)
    response.close()

This script will make an authenticated HTTP request to the specified URL using your username and password. If the authentication is successful, it will print the response data as a string. Note that this example uses basic authentication; other authentication methods, such as OAuth, may require different steps.

How To Authenticate Your HTTP Requests with requests

In this section, we will learn how to authenticate your HTTP requests using the requests module.

Here’s a step-by-step guide for basic authentication:

Step 1: Import the required module

First, import the required module. Import the requests module:

import requests

Step 2: Prepare your credentials

Store your username and password in variables for easy reference:

username = "your_username"
password = "your_password"

Step 3: Make the authenticated request

Use the auth parameter in the request function (e.g., get(), post()) to pass your username and password:

url = "https://api.example.com/data"

try:
    response = requests.get(url, auth=(username, password))
    response.raise_for_status()
    response_data_str = response.text
except requests.exceptions.HTTPError as e:
    print(f"An HTTP error occurred: {e}")
except requests.exceptions.RequestException as e:
    print(f"A request error occurred: {e}")
else:
    print(response_data_str)

Complete Example:

Here’s the complete example of authenticating HTTP requests with the requests module:

import requests

url = "https://api.example.com/data"
username = "your_username"
password = "your_password"

try:
    response = requests.get(url, auth=(username, password))
    response.raise_for_status()
    response_data_str = response.text
except requests.exceptions.HTTPError as e:
    print(f"An HTTP error occurred: {e}")
except requests.exceptions.RequestException as e:
    print(f"A request error occurred: {e}")
else:
    print(response_data_str)

Summary

In this tutorial, we covered various aspects of making HTTP requests using Python’s urllib and requests modules. We discussed how to install and import the modules, make simple HTTP GET and POST requests, add headers to your requests, handle HTTP errors and exceptions, work with JSON data, and authenticate your HTTP requests. Both urllib and requests modules provide functionalities for interacting with APIs and web services, but the requests module offers a more user-friendly interface and is generally recommended for most use cases.

Click to share! ⬇️