Navigating the "NodeJS Error: CERT_HAS_EXPIRED": Solutions and Best Practices


In the modern web, secure communication is paramount, making SSL/TLS certificates a cornerstone of secure Node.js applications. However, developers often encounter the “NodeJS Error: CERT_HAS_EXPIRED,” which occurs when a certificate used in the application or while accessing external resources has expired. This blog delves into understanding this error, exploring common scenarios, providing fixes, and discussing best practices to ensure your Node.js applications maintain secure, uninterrupted communication.

Understanding the Error

The “NodeJS Error: CERT_HAS_EXPIRED” indicates that an SSL/TLS certificate used in a Node.js application has reached its expiration date. SSL/TLS certificates are used to establish secure connections, and they have a validity period after which they must be renewed. When Node.js tries to establish a secure connection using an expired certificate, this error is thrown.

Diving Deeper

SSL/TLS certificates are time-bound for security reasons, ensuring that they are periodically renewed to maintain encryption standards. The error can arise both from certificates within your own application (e.g., for HTTPS servers) and from external resources your application is accessing (e.g., APIs with HTTPS).

Common Scenarios and Fixes with Example Code Snippets

Scenario 1: Expired Certificate in HTTPS Server

Problem: Setting up an HTTPS server with an expired certificate.


     const https = require('https');
const fs = require('fs');

const options = {
 key: fs.readFileSync('expired-key.pem'),
 cert: fs.readFileSync('expired-cert.pem')

https.createServer(options, (req, res) => {
 res.end('hello world\n');


Solution: Renew the SSL/TLS certificate and update the server configuration.


     const options = {
 key: fs.readFileSync('new-key.pem'),
 cert: fs.readFileSync('new-cert.pem')
// Rest of the server setup remains the same


Scenario 2: HTTPS Request to a Server with an Expired Certificate

Problem: Making an HTTPS request to an external server with an expired certificate.


     https.get('', (res) => {
 // handle response
}).on('error', (e) => {


Solution: If you trust the server, you can bypass the certificate validation (not recommended for production).


     const https = require('https');
const agent = new https.Agent({ rejectUnauthorized: false });

https.get('', { agent }, (res) => {
 // handle response


Scenario 3: Using Expired Client Certificates

Problem: Client-side certificates for authentication that have expired.


     const https = require('https');
const fs = require('fs');

const options = {
 cert: fs.readFileSync('expired-client-cert.pem'),
 key: fs.readFileSync('expired-client-key.pem'),
 // Other options

https.request('', options, (res) => {
 // handle response


Solution: Replace the client certificates with valid, updated ones.


     const options = {
 cert: fs.readFileSync('new-client-cert.pem'),
 key: fs.readFileSync('new-client-key.pem'),
 // Other options remain the same
// Rest of the request setup remains the same


Scenario 4: Certificates in Load Balancers or Reverse Proxies

Problem: Load balancers or reverse proxies with expired certificates.

Solution: Update the certificates in these components, often involving server configuration outside of Node.js.

Scenario 5: Expired CA Certificates

Problem: Certificate Authority (CA) certificates used for validating connections might expire.

Solution: Update the CA certificates bundle in your application or environment.

Scenario 6: Certificates in Third-party Modules

Problem: Using modules or SDKs that internally use expired certificates.

Solution: Update the third-party modules or SDKs to the latest version where certificates might be updated.

Scenario 7: Certificates in Development Environments

Problem: Development environments often use self-signed certificates which can expire.

Solution: Generate new self-signed certificates for development use.

Scenario 8: Handling Expired Certificates in External APIs

Problem: External APIs or services your application consumes might have expired certificates.

Solution: Contact the API provider to update their certificates or temporarily bypass certificate validation for testing.

Strategies to Prevent Errors

Regular Monitoring: Regularly check the expiry dates of all certificates used in the application.

Automated Alerts: Set up automated alerts for certificate expiration.

Certificate Management Tools: Utilize tools and services for managing SSL/TLS certificate lifecycles.

Best Practices

Avoid Bypassing Certificate Validation: While it’s a quick fix, it compromises security. Only use it temporarily in development or testing environments.

Use Certificate Rotation: Regularly rotate certificates even before they expire.

Keep Dependencies Updated: Regularly update any dependencies that might use SSL/TLS certificates.

Documentation: Keep a well-documented schedule of certificate expiry dates and renewal processes.


Handling the “NodeJS Error: CERT_HAS_EXPIRED” effectively requires a proactive approach to certificate management. By understanding the scenarios in which this error occurs and implementing the strategies and best practices outlined above, developers can ensure their Node.js applications remain secure and reliable. Remember, staying ahead of certificate expirations is key to maintaining the integrity of secure communications in your applications.