India English
Kenya English
United Kingdom English
South Africa English
Nigeria English
United States English
United States Español
Indonesia English
Bangladesh English
Egypt العربية
Tanzania English
Ethiopia English
Uganda English
Congo - Kinshasa English
Ghana English
Côte d’Ivoire English
Zambia English
Cameroon English
Rwanda English
Germany Deutsch
France Français
Spain Català
Spain Español
Italy Italiano
Russia Русский
Japan English
Brazil Português
Brazil Português
Mexico Español
Philippines English
Pakistan English
Turkey Türkçe
Vietnam English
Thailand English
South Korea English
Australia English
China 中文
Somalia English
Canada English
Canada Français
Netherlands Nederlands


Secure communication is paramount in today’s web applications. Python, a versatile programming language, offers robust tools for establishing secure connections using SSL (Secure Sockets Layer) certificates. However, you might occasionally stumble upon the “python ssl certificate_verify_failed” error, hindering your secure interactions. This blog post dives into understanding this error, its causes, and practical solutions to resolve it.

What is the “python ssl certificate_verify_failed” error?

The “python ssl certificate_verify_failed” error occurs when Python cannot validate the authenticity of an SSL certificate presented by a server during an HTTPS connection attempt. This failure in certificate verification signals a potential security risk, as Python cannot guarantee that the communication is with the intended server and not a malicious imposter.

Why Does Certificate Verification Matter?

SSL certificate verification is a crucial security mechanism. Here’s why it’s important:

  • Data Encryption: SSL certificates enable encryption of data transmitted between your Python code and a remote server, safeguarding sensitive information.
  • Identity Verification: SSL certificates help verify the server’s identity, mitigating the risk of man-in-the-middle attacks where an attacker might try to intercept communications.
  • Trust and Reliability: A valid SSL certificate fosters trust in the website or service you’re connecting to.

Common Causes of the “python ssl certificate_verify_failed” error

-> Incorrect or Expired SSL Certificate:

  • Self-Signed Certificates: Servers using self-signed certificates (those not issued by a recognized certificate authority) often cause this error. Python doesn’t implicitly trust these certificates.
  • Expired Certificates: Every SSL certificate has an expiration date. Python will reject connections if the server uses an expired certificate, as it raises security concerns.
  • Incorrect Domain Name: The certificate might be valid but issued for a different domain than the one your Python code is trying to connect to. Domain name mismatches lead to verification failure.

-> Missing Intermediate Certificates:

  • Certificate Chains: SSL certificates follow a chain of trust. A root certificate authority (CA) issues an intermediate certificate, which, in turn, might issue the actual server certificate.
  • Incomplete Configuration: If the server doesn’t provide the complete chain, including necessary intermediate certificates, Python might be unable to trace the certificate back to its trusted root, causing the error.

-> Outdated or Missing Root Certificates in Python:

  • Trust Store: Python maintains a set of trusted root certificates (also called a “CA bundle”). This trust store is how it determines if a certificate is ultimately trustworthy.
  • Obsolete Trust Store: If your Python installation has an outdated CA bundle, it might not recognize newer certificates issued by newer CAs or those updated with modern security standards.

-> Incorrect Time Settings:

  • System Time Sensitivity: SSL Certificates have ‘valid from’ and ‘valid until’ dates. If your system’s date or time is incorrectly set, it might mistakenly believe a certificate to be expired or not yet valid.

-> Firewall or Network Restrictions:

  • Certificate Validation Interference: Firewalls or network configurations might block the process Python uses to check the validity of an SSL certificate. This can include the revocation checking process (e.g., OCSP).
  • Proxy Issues: If your requests pass through a proxy, incorrect proxy settings or a misconfigured proxy can interfere with certificate verification.

How to Fix the “python ssl certificate_verify_failed” Error

Let’s explore several ways to fix the “python ssl certificate_verify_failed” error:

1. Update SSL Certificates (Server-Side)

If you have control over the server, ensure that the SSL certificate is valid, up-to-date, and includes all necessary intermediate certificates.

2. Use the ‘certifi’ Package

The ‘certifi’ package provides a comprehensive set of up-to-date root certificates. Install it using pip:


pip install certifi

Then, modify your Python code:


import requests
import certifi

url = ''
response = requests.get(url, verify=certifi.where()) 

3. Manually Specify the CA Certificate Bundle

If you know the specific certificate authority (CA) that issued the server’s certificate, you can provide the path to the CA certificate bundle:


import requests

url = ''
ca_cert_path = '/path/to/ca_bundle.pem' 
response = requests.get(url, verify=ca_cert_path) 

4. Disabling Certificate Verification (Caution!)

Warning: This method should be a last resort and only used in controlled development environments as it poses security risks.


import requests
import urllib3 

response = requests.get('', verify=False) 

5. Create an SSL Context

For fine-grained control over SSL settings, create a custom SSL context:


import ssl
import requests

context = ssl.create_default_context()
# Load CA certificates or customize verification
response = requests.get('', context=context) 

Additional Considerations

  • Operating System: Some operating systems may require specific setup for managing trusted certificates.
  • Python Versions: Different Python versions might have varying SSL behaviors.


The “python ssl certificate_verify_failed” error signals a potential security concern. By understanding the causes and applying the solutions outlined above, you can effectively troubleshoot and establish secure connections in your Python projects.

Read also:


Enjoy this blog? Please spread the word :)