How to handle basic authentication and other forms of authentication using Requests.

share link

by dot icon Updated: Sep 25, 2023

technology logo
technology logo

Solution Kit Solution Kit  

Authentication is checking if someone is who they say they are, like a user or system. Many places use this security method to protect information, systems, and data.  

Types of Authentications:  

  • User Authentication  
  • System Authentication  
  • Multi-factor Authentication  
  • Biometric Authentication  
  • Token-based Authentication  
  • Certificate-based Authentication  
  • OAuth and OpenID Connect  


Authentication is important because it confirms the identity of users, systems, or entities. It guarantees that they are who they say they are. It has many purposes. It enhances security, ensures accountability, safeguards privacy, and ensures compliance with regulations. In Python applications, authentication is important. Your chosen method depends on your needs, security, and user experience.  

1. Password Authentication:   

  • Description: Password authentication is the most traditional and widely used method. Users provide a username and password to access a system or application.  
  • Implementation: Applications usually save encrypted versions of user passwords in a database. When you log in, the system checks if your password matches the stored password.  
  • Security Considerations: For security, use strong hashing algorithms like bcrypt to authenticate passwords. We must protect user passwords, follow rules, and store passwords securely.  

2. Token Authentication:   

  • Description: Token authentication involves using tokens (usually short-lived) to authenticate users. After you log in, you get tokens. Each new request you make shows these tokens.  
  • Implementation: Common token types include JSON Web Tokens (JWTs) or opaque tokens. JWTs are self-contained and store user data in a digitally signed format. A central authority validates opaque tokens by querying them.  
  • Security Considerations: Token authentication can be secure when properly implemented and managed. To prevent tampering, you should sign and encrypt JWTs, for example. Token expiration and revocation mechanisms should also be in place.  

3.OAuth2 Authentication:   

  • Description: OAuth2 is a protocol for delegated authorization and authentication. When users log in, applications can access their data from Google or Facebook.  
  • Implementation: Python libraries, such as Authlib, support OAuth2 for client and server implementations. Django also has built-in support for OAuth2.  
  • Security Considerations: OAuth2 is a secure protocol when implemented correctly. Ensure that you protect tokens during transmission and securely store them.  

4.OpenID Connect (OIDC):   

  • Description: OIDC is a way to authenticate users using OAuth2. It gives user authentication information in a standard format.  
  • Implementation: You can use Python libraries like Authlib to implement OIDC. This allows for Single Sign-On (SSO) and retrieval of user profile information.  
  • Security Considerations: OIDC relies on OAuth2's security features. Ensure proper token management and protection.  


In conclusion, authentication is an integral part of building secure Python applications. It helps control user access, protect data, and meet regulatory requirements. You need strong ways to prove your identity to protect your application and data. With better technology and more complex threats, we require strong, flexible tools. They are important for keeping your application secure and available.  

Fig: Preview of the output that you will get on running this code from your IDE.


In this solution we are using Request library of Python.

import requests
from datetime import timedelta, date

def daterange(start_date, end_date):
    for n in range(int((end_date - start_date).days)):
        yield start_date + timedelta(n)

start_date = date(2016, 1, 1)
end_date = date(2019, 7, 31)

# ***********************
# overriding requests.Session.rebuild_auth to maintain headers when redirected
# ***********************
class SessionWithHeaderRedirection(requests.Session):
    AUTH_HOST = ''

    def __init__(self, username, password):
        self.auth = (username, password)

    # Overrides from the library to keep headers when redirected to or from the NASA auth host.
    def rebuild_auth(self, prepared_request, response):
        headers = prepared_request.headers
        url = prepared_request.url
        if 'Authorization' in headers:
            original_parsed = requests.utils.urlparse(response.request.url)
            redirect_parsed = requests.utils.urlparse(url)
            if (original_parsed.hostname != redirect_parsed.hostname) and \
               redirect_parsed.hostname != self.AUTH_HOST and \
               original_parsed.hostname != self.AUTH_HOST:
                del headers['Authorization']

# create session with the user credentials that will be used to authenticate access to the data
username = "USERNAME"
password = "PASSWORD"
session = SessionWithHeaderRedirection(username, password)

# ***********************
# Loop through Files
# ***********************
for single_date in daterange(start_date, end_date):
    YYYY = single_date.strftime("%Y")
    MM = single_date.strftime("%m")
    DD = single_date.strftime("%d")
    fpath1 = '' + YYYY + '/' + MM + '/'
    fpath2 = 'MERRA2_400.inst1_2d_asm_Nx.' + YYYY + MM + DD + ''
    fpath3 = 'U2M[0:23][94:160][469:534],TROPT[0:23][94:160][469:534],TROPPB[0:23][94:160][469:534],' \
             'T2M[0:23][94:160][469:534],TQL[0:23][94:160][469:534],TOX[0:23][94:160][469:534],' \
             'PS[0:23][94:160][469:534],V50M[0:23][94:160][469:534],DISPH[0:23][94:160][469:534],' \
             'TO3[0:23][94:160][469:534],TS[0:23][94:160][469:534],T10M[0:23][94:160][469:534],' \
             'TROPPT[0:23][94:160][469:534],TQI[0:23][94:160][469:534],SLP[0:23][94:160][469:534],' \
             'TQV[0:23][94:160][469:534],V2M[0:23][94:160][469:534],TROPQ[0:23][94:160][469:534],' \
             'V10M[0:23][94:160][469:534],U50M[0:23][94:160][469:534],U10M[0:23][94:160][469:534],' \
             'QV2M[0:23][94:160][469:534],TROPPV[0:23][94:160][469:534],' \
    url = fpath1 + fpath2 + fpath3
    # print(url)

    # extract the filename from the url to be used when saving the file
    filename = 'MERRA2_400.inst1_2d_asm_Nx.' + YYYY + MM + DD + ''

        # submit the request using the session
        response = session.get(url, stream=True)

        # raise an exception in case of http errors

        # save the file
        with open(filename, 'wb') as fd:
            for chunk in response.iter_content(chunk_size=1024 * 1024):

    except requests.exceptions.HTTPError as e:
        # handle any errors here


Follow the steps carefully to get the output easily.

  1. Download and Install the PyCharm Community Edition on your computer.
  2. Open the terminal and install the required libraries with the following commands.
  3. Install request - pip install request.
  4. Create a new Python file on your IDE.
  5. Copy the snippet using the 'copy' button and paste it into your Python file.
  6. Run the current file to generate the output.

I hope you found this useful.

I found this code snippet by searching for 'Can't get authorisation to work with python requests' in Kandi. You can try any such use case!

Environment Tested

I tested this solution in the following versions. Be mindful of changes when working with other versions.

  1. PyCharm Community Edition 2023.2.1
  2. The solution is created in Python 3.8 Version
  3. Requests 3.4 version.

Using this solution, we can be able to create handle basic authentication and other forms of authentication using Requests. This process also facilities an easy way to use, hassle-free method to create a hands-on working version of code which would help us to create handle basic authentication and other forms of authentication using Requests.

Dependent Library

requestsby psf

Python doticonstar image 49787 doticonVersion:v2.31.0doticon
License: Permissive (Apache-2.0)

A simple, yet elegant, HTTP library.


            requestsby psf

            Python doticon star image 49787 doticonVersion:v2.31.0doticon License: Permissive (Apache-2.0)

            A simple, yet elegant, HTTP library.

                      You can search for any dependent library on Kandi like 'requests.


                      1. How does OAuth2 work, and what are its benefits in Python?   

                      OAuth2 is a safe way for users to allow others to access their resources. It's used for third-party app access. Python and other programming languages let apps work with user data and services. It keeps user credentials hidden.   


                      2. What does the Python Requests Module do, and how can we use it for authentication?   

                      The Python requests module is a popular library for making HTTP requests in Python. It simplifies sending HTTP requests to web services or APIs and handling responses. You can use it to interact with web resources and make authenticated requests.   


                      3. What is basic user authentication, and how is it implemented in a Python web application?   

                      User authentication is important for web security. It confirms the identity of people using an application. It involves users providing a username and password to prove their identity. Once users authenticate themselves, they can access restricted areas or specific functions.   

                      • User Database   
                      • User Registration   
                      • User Login   
                      • Session Management   
                      • Authorization   
                      • Logout   
                      • Password Reset and Recovery  
                      • Security Best Practices   
                      • Testing and Validation   
                      • Logging and Monitoring   


                      4. How do web APIs use authentication to verify requests?   

                      Web APIs verify the identity of clients or users who want to use their resources or services. Authentication ensures that only approved individuals can access the API and protect data.   


                      5. What are some good ways to secure passwords in a Python web app?   

                      Password authentication is a critical aspect of web application security. A Python web app can keep user accounts and important info safe with passwords.   

                      • Use a Secure Password Hashing Algorithm   
                      • Salt Passwords   
                      • Install Password Policies  
                      • Use a Password Reset Mechanism   
                      • Implement Account Lockout   
                      • Rate Limit Authentication Attempts   
                      • Secure Password Storage   
                      • Protect Against CSRF Attacks  
                      • Avoid Revealing Authentication Errors   


                      1. For any support on kandi solution kits, please use the chat
                      2. For further learning resources, visit the Open Weaver Community learning page

                      See similar Kits and Libraries