A Complete Guide - NodeJS Environment Variables and dotenv

Last Updated: 03 Jul, 2025   
  YOU NEED ANY HELP? THEN SELECT ANY TEXT.

Node.js Environment Variables and dotenv: A Comprehensive Guide

In software development, environment variables are a way to manage external configurations without embedding them directly within the codebase. They are dynamic-named values that can affect the way running processes will behave on a computer. In the context of Node.js, environment variables are commonly used to store sensitive information like API keys, database credentials, configuration settings, and more, which can vary between development, testing, and production environments.

Why Use Environment Variables?

  1. Security: Protect against leaks of sensitive information by keeping secrets out of your codebase.
  2. Flexibility: Easily switch between different configurations (e.g., development vs. production) without modifying the source code.
  3. Separation of Concerns: Configuration settings should not be hardcoded in your application logic.
  4. Scalability: Allows for scaling environments more efficiently as each instance or server can have its own set of environment variables.

Setting Environment Variables in Node.js

There are several ways to set environment variables in Node.js:

  1. Command Line: You can set them before starting your node process.

    NODE_ENV=production node app.js

  2. Operating System Configuration: Environment variables can also be configured in the OS-level settings.

  3. Configuration Files: Storing environment variables in files is another approach.

dotenv Package

dotenv is a zero-dependency module that loads environment variables from a .env file into process.env. Storing configuration in the environment rather than in the code is based on npm install dotenv

  • Create a .env File Create a .env file at the root of your project and add your configuration inside it:

    DB_HOST=localhost
DB_USER=root
DB_PASS=s1mpl3
PORT=3000
API_KEY=your_api_key_here

  • Configure dotenv in Your Application In your main application entry file (commonly index.js or app.js), require and configure dotenv at the very top of the file before importing any other modules:

    require('dotenv').config(); const express = require('express');
const app = express(); // Now you can access your environment variables using process.env.VARIABLE_NAME
const port = process.env.PORT || 3000;
const dbHost = process.env.DB_HOST;
const dbUser = process.env.DB_USER;
const dbPass = process.env.DB_PASS;
const apiKey = process.env.API_KEY; // For example, setting up a database connection
const mysql = require('mysql');
const dbConnection = mysql.createConnection({ host: dbHost, user: dbUser, password: dbPass, database: 'example_db'
}); dbConnection.connect((err) => { if (err) throw err; console.log('Connected to MySQL Database!');
}); app.get('/', (req, res) => { res.send(`Welcome to our API with access to API_KEY=${apiKey}`);
}); app.listen(port, () => { console.log(`Server is running on port ${port}`);
});

  • Using Multiple .env Files While dotenv reads the .env file by default, you can use different .env files for different environments. For example, you can have:

    • .env.development
    • .env.test
    • .env.production

    Then, specify the path in the config method:

    require('dotenv').config({ path: `.env.${process.env.NODE_ENV}` });

  • Avoiding Leaks Always add your .env and other sensitive files into the .gitignore of your project to prevent them from being pushed to version control systems like GitHub:

    # Ignore env files.
.env
.env.local
.env.*.local

  • Error Handling Optionally, you can handle errors thrown by dotenv:

    const result = require('dotenv').config(); if (result.error) { throw result.error
} console.log(result.parsed);

  • Loading Specific Files Based on Conditions You can load different .env files based on specific conditions or logic in your application:

    let envFile = '.env';
if (process.env.NODE_ENV === 'development') { envFile = '.env.development';
} else if (process.env.NODE_ENV === 'test') { envFile = '.env.test';
} else if (process.env.NODE_ENV === 'production') { envFile = '.env.production';
}
require('dotenv').config({ path: envFile });

  • Best Practices

    • Use environment variables for different sets of configuration.
    • Encrypt sensitive data stored in environment variables.
    • Keep your .env files private and secure.

  • Accessing in JavaScript Code After loading the .env file, you can access these variables anywhere in your application using process.env.VARIABLE_NAME.

    const host = process.env.DB_HOST || 'default_host';
const port = process.env.DB_PORT || 5432;

  • Advanced Configuration dotenv supports options like encoding, debug, etc. Check

    Online Code run

    🔔 Note: Select your programming language to check or run code at

    💻 Run Code Compiler

    • Step-by-Step Guide: How to Implement NodeJS Environment Variables and dotenv

    Complete Examples, Step by Step for Beginners: NodeJS Environment Variables and dotenv

    Step 1: Set Up a New Node.js Project

    First, ensure you have Node.js and npm (Node Package Manager) installed on your machine. You can download them from mkdir nodejs-env-demo cd nodejs-env-demo

  • Initialize a new Node.js project:

    npm init -y

    This will create a package.json file with default settings.

    • Step 2: Install the dotenv Package

    The dotenv package reads from a .env file in your project directory and sets the environment variables defined in that file as process.env.VARIABLE_NAME.

    1. Install dotenv:

      npm install dotenv

    Step 3: Create a .env File

    The .env file contains the environment variables that your application will use.

    1. Create a .env file in the root of your project directory:

      touch .env

    2. Add some environment variables to the .env file:

      API_KEY=1234567890
DB_HOST=localhost
DB_USER=root
DB_PASS=s1mpl3

      It's important to keep this file out of version control, as it may contain sensitive information. To do this, add the .env file to your .gitignore file:

      echo ".env" >> .gitignore

    Step 4: Load Environment Variables in Your Application

    Now that you have your environment variables set up, you need to load them in your Node.js application.

    1. Create a new JavaScript file, e.g., index.js:

      touch index.js

    2. Load the environment variables and use them in your application:

      Open index.js in a text editor and add the following code:

      // index.js // Load environment variables from .env file
require('dotenv').config(); // Access the environment variables
const apiKey = process.env.API_KEY;
const dbHost = process.env.DB_HOST;
const dbUser = process.env.DB_USER;
const dbPass = process.env.DB_PASS; // Print the environment variables to the console
console.log(`API Key: ${apiKey}`);
console.log(`Database Host: ${dbHost}`);
console.log(`Database User: ${dbUser}`);
console.log(`Database Password: ${dbPass}`);

    Step 5: Run Your Application

    Now that everything is set up, you can run your Node.js application to see the environment variables in action.

    1. Run the application using Node.js:

      node index.js

    2. You should see the following output:

      API Key: 1234567890
Database Host: localhost
Database User: root
Database Password: s1mpl3

    Conclusion

    In this step-by-step guide, you learned how to manage environment variables in a Node.js application using the dotenv package. By storing configuration settings in a .env file and loading them at runtime, you can easily manage different configurations for development, testing, and production environments.

     YOU NEED ANY HELP? THEN SELECT ANY TEXT.

    Top 10 Interview Questions & Answers on NodeJS Environment Variables and dotenv

    Top 10 Questions and Answers on NodeJS Environment Variables and dotenv

    1. What are Environment Variables in Node.js?

    2. Why should I use Environment Variables in my Node.js project?

    Answer: Using environment variables helps keep sensitive information out of your source control, making it easier to manage different configurations for development, testing, production, and other environments. It allows multiple users to work on the same codebase without exposing sensitive data, reduces the risk of accidental commits of secrets, and promotes security best practices.

    3. What is the dotenv package in Node.js?

    Answer: The dotenv package is a zero-dependency module that loads environment variables from a .env file into process.env. It simplifies the process of managing configuration settings in a more secure and organized way by allowing you to set environment variables outside of your codebase.

    4. How do I install the dotenv package in my Node.js project?

    Answer: To install the dotenv package, you can use npm or yarn. Run the following command in your project directory:

    npm install dotenv

    Or with yarn:

    yarn add dotenv

    5. How do I create a .env file and use dotenv to load the variables?

    Answer: Create a .env file in the root directory of your Node.js project. Inside this file, you can define your environment variables like so:

    DB_HOST=localhost
DB_USER=root
DB_PASS=s1mpl3

    Then, in your main application file (usually index.js or app.js), require and configure dotenv at the very top:

    require('dotenv').config();

    Now, you can access your variables using process.env:

    console.log(process.env.DB_HOST); // Output: localhost

    6. Should I commit the .env file to version control?

    Answer: No, you should never commit your .env file to a version control system like git. This file contains sensitive information that could expose your application to security vulnerabilities. Instead, include the .env file in your .gitignore so it is not tracked.

    # .gitignore
.env

    7. How do I handle different environment settings for development, testing, and production?

    Answer: To manage different settings for various environments, you can create multiple .env files, such as .env.development, .env.production, and .env.test. You can then specify which file to load based on the current environment using a different configuration in your application. A common approach is to use the NODE_ENV variable to determine which .env file to load:

    require('dotenv').config({ path: `.env.${process.env.NODE_ENV || 'development'}` });

    8. How can I use environment variables with Docker in a Node.js project?

    Answer: When using Docker, you can pass environment variables using the ENV instruction in your Dockerfile or by setting them in a separate .env file and using --env-file option with docker-compose. Here’s how you can define environment variables in a Dockerfile:

    ENV DB_HOST=localhost
ENV DB_USER=root
ENV DB_PASS=s1mpl3

    Or with docker-compose, create a docker-compose.yml file:

    version: '3'
services: app: build: . env_file: - .env.production

    This approach keeps your configuration flexible and your Docker images independent of specific environment settings.

    9. How do I securely manage environment variables in production?

    Answer: In production, it is not recommended to use a .env file to store sensitive information. Instead, consider using cloud-based secrets management services such as AWS Secrets Manager, Azure Key Vault, or HashiCorp Vault. These services provide secure storage, access control, and encryption for your secrets. You can access the secrets from your application using the respective SDKs provided by each service.

    10. What are some best practices when using environment variables in Node.js?

    Answer: Here are some best practices:

    • Exclusive .env File: Use a separate .env file that is never committed to version control.
    • Environment Separation: Use different files for different environments (e.g., .env.development, .env.production).
    • Security: Store sensitive information securely using secrets management services in production.
    • Variable Naming: Use consistent and descriptive names for your environment variables.
    • Documentation: Document all variables and their expected values to help other team members understand your configuration requirements.

    You May Like This Related .NET Topic

    📥 Download Code ▶️ Watch Online 📖 Read Description

    Login to post a comment.