Use an inline assignment for a one-off launch, or put variables in a PM2 ecosystem file for repeatable deployments. For example, API_URL=https://api.example.com pm2 start app.js makes the value available to Node.js as process.env.API_URL. If the process already exists, restart or reload it with --update-env so a changed CLI value is copied into the managed process. For production and staging, define separate env_* blocks in ecosystem.config.js and select one with --env.
Need a server to try this on? Antihost offers Linux VPS plans with NVMe storage, full root access and a 14-day free trial.
How PM2 passes variables to Node.js
PM2 starts your Node.js process with an environment map. Node exposes that map through the global process.env object, so application code does not need a PM2-specific API:
As an Amazon Associate I earn from qualifying purchases.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11const apiUrl = process.env.API_URL;
console.log(apiUrl);There are two documented ways to create that map with PM2:
- Inline shell assignment: prepend
NAME=valueto apm2 start, restart, or reload command. - Ecosystem file: declare an
envobject, plus optional named objects such asenv_productionorenv_staging, in a JavaScript configuration file.
The choice is mainly about repeatability. An inline assignment is convenient for a quick override. An ecosystem file gives every operator the same named configuration and makes switching environments explicit.
#1 Best Overall
- [Ultra-Lightweight Ear Buds Designed for Small Ears] Each earbud weighs only 3.7g and features a compact, ergonomic in-ear design made especially for small ears. Secure, low-profile, and comfortable for workouts, all-day wear or overnight sleeping.The ultra-slim profile sits flush in your ear with no hard edges poking or rubbing, so you can even sleep on your side without discomfort.
- [Immersive Stereo Sound with TOZO OrigX Technology] TOZO OrigX tuning delivers clear vocals, balanced mids, and natural stereo sound for music, podcasts, and videos.
- [Long Battery Life for Daily Use] Get up to 7 hours of playtime on a single charge, with up to 32 hours total using the charging case—ideal for workdays, commuting, and extended listening sessions.
- [Bluetooth 5.3 & Stable Connection] Bluetooth 5.3 provides fast pairing, stable wireless performance, and reduced dropouts as you move around home or office.
- [Deep Bass with Clear Vocals] High-performance drivers produce punchy bass while keeping vocals clean and detailed for everyday listening.
Environment variables are attached when PM2 launches the process. They are not a live configuration database that Node polls after startup. If a value changes, the process must be restarted or reloaded so the new environment reaches the new process instance. This distinction explains why editing a shell command or configuration file alone does not change what an already running application sees.
Method 1: pass a variable on the PM2 command line
Start a new application with an inline value
In a POSIX shell, place the assignment immediately before the PM2 command:
Free tools Windows power users keep installed
One-click scans. No signup required.
API_URL=https://api.example.com pm2 start app.jsPM2 starts app.js with API_URL set. Read it in the application with:
const apiUrl = process.env.API_URL;
if (!apiUrl) {
throw new Error('API_URL is required');
}The assignment applies to that command invocation. It is useful for a temporary endpoint, a one-off maintenance process, or testing a value without editing a configuration file. Keep the value unquoted when it contains no shell metacharacters; quote values that contain spaces or characters your shell would interpret:
FEATURE_MESSAGE='maintenance mode' pm2 start app.jsDo not confuse this syntax with an argument passed to your JavaScript program. API_URL=... becomes part of the process environment; it is not available in process.argv.
Multiple variables can be supplied on the same command by placing assignments next to one another:
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →NODE_ENV=staging API_URL=https://staging-api.example.com pm2 start app.jsThis remains shell-controlled configuration, so document or script the complete command if another operator must reproduce it. The command also inherits other variables exported by the shell or host. Be deliberate about that inheritance: a local terminal may contain values that are absent when PM2 is launched by a deployment account or service process.
Change a value on an existing process
PM2 treats CLI-provided environment conservatively. A new shell assignment does not automatically replace the value held by an already managed process. Supply --update-env when restarting or reloading:
API_URL=https://new-api.example.com pm2 restart app --update-envThe same flag can be used with a reload:
API_URL=https://new-api.example.com pm2 reload app --update-envWithout the flag, PM2 can restart the process while retaining the environment it previously stored. That is why an application may continue to print an old value even though the command shown in your shell contains a new one. Include the flag every time a CLI assignment is intended to replace an existing value.
The assignment and the flag have different jobs: API_URL=... supplies the candidate value to the PM2 command, while --update-env tells PM2 to refresh the managed process environment from that command. Omitting either part can leave the application with an unexpected value.
Rank #2
- 【IP68 Waterproof Multifunctinal Smart Watch】Torjalph fitness activity tracker smart watch is IP68 waterproof technology ,you can wear it when swimming,handwashing,it's rain-proof which means that you perform multiple exercise modes outside without worrying about sweat or rain corroding your fitness smart watch,and this watch equipped with a 230 mAh large capacity battery magnetic charging ,and this sports activity tracker watch can be used 5-7 days If fully charged.
- 【Larger 1.83'' Full Screen Watch & Multi-dial Selection】1.83 inch full HD color touch screen smart watch for men / women provides excellent 240*284 resolution image quality ,This Bluetooth smart watch offers a better touch experience and remarkable immersion and ,more than 200 watch faces for you to choose from App"Da Fit ", you can change the dial style according to your mood to wear keeping the world on your wrist
- 【Accurate Activity Tracker Smart Watch 】sports watch activity tracker uses sweat and dust resistant breathable silicone strap, our Fitness Tracker Smart Watch for Android iOS Phones supports 12 sports modes,walking,running,bicycle,swimming,badminton,basketball,football,rope skipping. This bluetooth calls smart watch for men women is lightweight and stylish, bringing more convenient and relaxing sports experience while also providing more protection.
- 【Your 24 Hour Personal Daily Health Monitor】Fitness watch for women men full touch screen IP67 waterproof bluetooth smartwatch for Android iOS Phones with heart rate blood pressure monitor multifunction Andriod smart watch with steps counter sleep monitor sports fitness watch, monitoring blood oxygen saturation allows you to understand your physical condition in real time to track fitness progress ,to know your health status in time.
- 【More Functions Bluetooth Call Smart Watch】This fitness activity smart watch full screen for iPhone and Android phones includes a bunch of new features including:The bluetooth smart watch can hang up the phone, receive and display WhatsAPP /Text /Facebook /Twitter /Messenger reminder.Support sedentary reminder, alarm clock, stopwatch, timer,weather information,music control, remote camera control compatible with Android 5.0 and above or iOS 9.0 and above smartphones.
Use the process name or an identifier consistently
The target in pm2 restart app is the PM2 application name (or another selector PM2 accepts), not necessarily the filename. If several applications are running, verify that the command addresses the intended process before changing a shared endpoint or feature flag. A practical sequence is:
- List the managed applications with
pm2 listand identify the exact name. - Run the assignment together with
pm2 restart <name> --update-envorpm2 reload <name> --update-env. - Inspect the application log or an authenticated diagnostic endpoint to confirm the new value was read at startup.
Replace <name> with the real PM2 name; do not leave the angle-bracket notation in a command. If you use a numeric identifier, confirm it still refers to the same process after deployments; a stable name is easier for scripts and runbooks to communicate.
Method 2: define variables in an ecosystem file
Create a repeatable default configuration
An ecosystem file gathers the application definition and its environment in one place. Save this as ecosystem.config.js beside your deployment files:
module.exports = {
apps: [{
name: 'my-node-app',
script: './app.js',
env: {
NODE_ENV: 'development',
API_URL: 'http://localhost:3000'
},
env_production: {
NODE_ENV: 'production',
API_URL: 'https://api.example.com'
},
env_staging: {
NODE_ENV: 'staging',
API_URL: 'https://staging-api.example.com'
}
}]
};The env object is the default set injected into the application. Start it with:
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →pm2 start ecosystem.config.jsIn the example, that command starts the development values because they are in the default env block.
Use the ecosystem file when the same application definition must be started by several people, machines, or deployment jobs. The script path, process name, and variable names are visible together, reducing the chance that one command omits a required setting. Keep comments or accompanying documentation for values whose purpose is not obvious, but do not place plaintext credentials in a publicly accessible repository.
Select production or staging explicitly
Named blocks follow the pattern env_<name>. Select the suffix with --env <name>:
pm2 start ecosystem.config.js --env production
pm2 start ecosystem.config.js --env stagingThe selector and suffix must match exactly: env_production pairs with --env production, while env_staging pairs with --env staging. A spelling or capitalization mismatch means PM2 cannot select the block you intended.
Keep the names meaningful and finite. A small set such as development, staging, and production is easier to audit than ad-hoc names created for individual servers. The file can contain multiple applications; each application can define its own environment blocks.
The default block and named blocks are not separate files or separate applications. They are alternative values for the same declared app. Make the selector part of your deployment command rather than relying on whoever ran the previous command. This prevents a production host from accidentally retaining the default development configuration after a process is recreated.
Rank #3
- [Low Noise High Fidelity] New bee guitar cord with 22AWG oxygen-free-copper center conductors provides enhanced signal transfer, the PVC insulation material and the high-density stranded copper double shield provide noise rejection for quiet operation
- [Ideal for Choice] New bee 1/4 straight and right angle metal connectors, ensures a secure connection in any instrument, pedal, or amp jack. L shape great fro on stage guitar stands
- [Wide Compatible] Suitable for mixer, power amplifier, microphone, effector, decoder, equalizer, electoronic organ, electric guitar, electric bass and other electronic equipments. Widely used in the installation of smart home, karaoke speaker, professional stage audio, etc
- [Easy Disassemble] Making incidental repairs quick and easy! Very nice, flexible cable
- [Dont Hesite to Order] 24 hours customer services and professional technology team are standing by
Apply edits after changing the ecosystem file
When you edit an ecosystem file, restart or reload the application so PM2 reads the new values:
pm2 restart ecosystem.config.js --env production
pm2 reload ecosystem.config.js --env productionPM2 applies changed ecosystem-file variables during the restart or reload. The --update-env flag is specifically important for changed CLI assignments; do not rely on it as a substitute for selecting the correct ecosystem block. If the file defines several apps and you want to affect only one, use the ecosystem-file selector:
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
pm2 restart ecosystem.config.js --env production --only my-node-appThis avoids unintentionally restarting every application declared in the file.
Use the same file path and environment selector for the restart that you used for the start. Restarting a different ecosystem file, or restarting without --env production, can make a correct edit appear ineffective because PM2 is reading another definition or the default block. After the operation, verify both process health and a non-secret value that identifies the selected environment.
Choosing between inline assignments, an ecosystem file, and external injection
| Method | Best for | Environment switching | Updating a running app | Repeatability |
|---|---|---|---|---|
Inline CLI (NAME=value pm2 start) |
One-off starts or quick overrides | Controlled by the shell command | Use --update-env on restart or reload |
Low unless the command is scripted |
Ecosystem env and env_* |
Shared defaults and named deployment configurations | Use env_<name> with --env <name> |
Restart or reload after editing the file | High |
| External secret or platform injection | Secrets managed by the host or deployment system | Controlled outside the application file | Depends on how the host exports values; PM2 receives the resulting process environment | Medium to high |
The third row is an operational pattern rather than a PM2 configuration feature. A deployment platform can export values before invoking PM2, or a host can provide them through its own secret-management workflow. PM2 then passes the resulting environment to Node.js just as it would any other inherited variable.
Choose inline values when speed matters more than a durable record. Choose an ecosystem file when environment selection, process naming, and repeatable restarts matter. Choose external injection for credentials and infrastructure-owned settings, while keeping the names expected by the application consistent across all three methods. The application still reads every option through process.env; only the delivery mechanism changes.
Recommended Free Tools
Read and validate variables in application code
Access values with process.env
Environment values arrive as strings. Convert them deliberately when your application expects another type:
const port = Number.parseInt(process.env.PORT || '3000', 10);
const debug = process.env.DEBUG === 'true';For a required setting, fail during startup rather than allowing a later request to fail ambiguously:
function required(name) {
const value = process.env[name];
if (!value) {
throw new Error(`Missing required environment variable: ${name}`);
}
return value;
}
const apiUrl = required('API_URL');Validation belongs in the application because PM2 injects values but does not know which ones your code requires, what format they should have, or whether a URL points to the right service.
Validate at the configuration boundary, before opening listeners or accepting requests. Check more than presence when the setting has a required shape: a port should parse as a valid number, a URL should be acceptable to the application, and a mode should be one of the values your code supports. Keep the error message specific about the variable name, but never include the secret value itself.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Repair Windows errors before they cause bigger problems3Scan for outdated or missing drivers - takes under a minuteRank #4
- Digital Family Calendar: BSIMB digital calendar wall touch screen puts an end to your chaotic life. Designed for busy families, the digital calendar keeps you organised and in step with your family. Assign different colours and tasks to each family member to make family scheduling easier and more intuitive.
- Easy Setup and Auto-Sync: Plug in, connect to WLAN and auto-syn your electric calendar in minutes. Digital wall calendar compatible with Google calendar, iCloud calendar, Outlook calendar, Cozi calendar and Yahoo calendar. Add events directly on the device or through the ecalendar app. Electronic calendar stays current whether you're at work or traveling—no manual updates needed.
- All-In-One Home Assistant: Smart calendar builds habits and encourage independence with personalised chores. Display daily meal plan to reduce the daily ‘What's for dinner?’ stress. To-do lists keep track of everything you want. Turning chores into valuable achievements with stars and rewards, making life easier and more enjoyable.
- Manage Anytime Anywhere: BSIMB electronic calendar for family stay connected with the powerful ecalendar app. Access and manage your digital wall calendar anytime, anywhere with free features like stars & rewards, photo screensaver, chore charts, meals plans, to-do lists etc. Electronic planner paid features like Magic Import tailor advanced tools for users with special needs.
- Stay in Touch with Loved Ones: Share photos or videos from your phone to electronic wall calendar with app, instantly update your life moment, and keep in touch with your family, especially those who are far away; you can also surprise your smart calendar digital wall by sending him a wish card; it's also great for keeping tech-illiterate elders in touch with the youngsters.
Expose diagnostics without leaking secrets
During troubleshooting, log the variable name and a safe summary, not credentials or tokens. For example, log the selected environment and API host while omitting an entire database URL if it contains a password. Remove temporary diagnostics after confirming the deployment. PM2’s environment mechanism does not encrypt values displayed by your application, shell history, process tooling, or logs.
A useful diagnostic separates selection from value content: report that the staging block was selected, or that API_URL has a particular host, without printing authorization headers, passwords, private keys, or full connection strings. Test the diagnostic path with the same account and command used by deployment, since a value visible in an interactive shell may not be exported in that context.
Production and staging workflow
A predictable multi-environment workflow separates selection from code changes:
- Define the application once. Put the script path, process name, and environment blocks in
ecosystem.config.js. - Keep non-secret defaults reviewable. Values such as
NODE_ENVand a service hostname can live in the appropriate block. - Inject secrets at deployment time. Use the host or deployment system’s secret process rather than committing plaintext production credentials to a public repository.
- Start with an explicit selector. Run
pm2 start ecosystem.config.js --env stagingfor staging or the corresponding production command. - Restart after configuration edits. Run the same file and selector with
pm2 restartorpm2 reload. - Verify from the running process. Confirm the expected non-secret value and application health, then check logs for startup validation errors.
Using the same file and selector on every server prevents a common drift problem: one machine running the default block while another is running production values.
Keep a record of which selector a deployment job used, especially when the same ecosystem file serves multiple environments. A rollback should repeat a known command and environment choice, not depend on whichever variables happen to remain in a login shell. When a secret rotates, inject the replacement through the protected deployment process and restart or reload so the new process receives it.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Why process.env is undefined or empty under PM2
The variable was never supplied
PM2 cannot invent a name that is absent from the command, ecosystem block, or inherited host environment. Add it to the inline assignment or the selected env/env_* object, then restart the process.
The running process kept an old CLI environment
If you changed an inline value, restart or reload with --update-env. Merely changing the command in your shell does not update an already managed process.
The wrong ecosystem block was selected
Check the exact pair. For env_production, the command must include --env production. If you run the file without --env, PM2 uses the default env block.
The edited file is not the file PM2 started
When multiple ecosystem files or working directories exist, confirm the path in the command and the script entry inside the file. Restart the intended file explicitly. With multiple applications in one file, add --only and the exact application name.
The value is read before the expected startup path
Read configuration after the process starts with the intended environment, and avoid overwriting process.env in application initialization. A startup validation function placed near configuration loading makes the failure immediate and visible in PM2 logs.
A plain .env file was assumed to be automatic
PM2’s documented env objects and CLI assignments do not mean PM2 automatically parses every .env file. If your application uses a dotenv loader or a Node runtime option, configure that mechanism separately and make sure it runs before the values are consumed. Otherwise, copy the required values into the PM2 environment through the ecosystem file, the shell, or your deployment platform.
This is a common local-versus-server discrepancy. A developer may have a local loader that reads .env before the app starts, while the PM2 command on the server does not invoke that loader. Decide explicitly whether PM2, Node, the application, or the deployment platform is responsible for loading values, and test that path in the same account and working directory used in production.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Troubleshooting checklist
| Symptom | Likely cause | Corrective action |
|---|---|---|
| A changed CLI value is not visible | PM2 retained the environment of the managed process | Repeat the assignment and run pm2 restart <name> --update-env or the equivalent reload command |
| The app starts with development values | The default env block was used |
Start or restart with --env production or --env staging |
| A named environment appears empty | The block suffix and selector do not match | Pair env_production with --env production, character for character |
| One app changed while another did not | The command targeted a different app or file | Check pm2 list, the ecosystem path, and use --only with the intended app name |
| The variable is undefined in Node | It was not included in the selected environment | Add it to the inline command, selected ecosystem block, or host-provided environment, then restart |
| Configuration works locally but not under PM2 | Local shell exports or a local .env loader are absent in the PM2 start context |
Make the loading mechanism explicit and validate required values at startup |
When diagnosing, change one variable at a time and verify the process after the restart. First confirm the PM2 target with pm2 list, then confirm the command’s file and selector, then inspect a safe startup message. This order distinguishes a selection error from an application parsing error and avoids exposing sensitive configuration while debugging.
Common mistakes to avoid
- Changing a command but not the managed process: use
--update-envfor changed CLI assignments. - Mixing selector names:
env_prodis not selected by--env production; the suffix is part of the contract. - Editing the wrong configuration: check the path and the declared application name before restarting.
- Assuming every variable is a number or boolean: parse and validate string values explicitly.
- Printing credentials while debugging: log safe metadata only, and keep secrets out of source control and logs.
- Assuming PM2 reads arbitrary
.envfiles: use a configured loader or inject values through PM2 or the deployment platform. - Restarting every application unnecessarily: use
--onlywhen an ecosystem file contains multiple apps and only one configuration changed. - Relying on an interactive shell: ensure the deployment account exports the same required values when PM2 is started non-interactively.
- Forgetting that reload is still a configuration event: confirm the replacement process receives the intended environment and watch startup logs for validation failures.
A compact command reference
| Goal | Command |
|---|---|
| One-off start with a value | API_URL=https://api.example.com pm2 start app.js |
| Apply a changed CLI value | API_URL=https://new-api.example.com pm2 restart app --update-env |
| Start the ecosystem default | pm2 start ecosystem.config.js |
| Start production block | pm2 start ecosystem.config.js --env production |
| Start staging block | pm2 start ecosystem.config.js --env staging |
| Reload one app from a selected block | pm2 reload ecosystem.config.js --env production --only my-node-app |
For scripts, keep the command’s assignment, PM2 action, target name, selector, and update behavior together. That makes it clear whether the script is creating a process, refreshing a CLI environment, or applying an ecosystem-file edit.
Final deployment checklist
- The application reads configuration through
process.env. - Every required variable is present in the command, selected ecosystem block, or host injection.
- Production and staging names match their
env_*suffixes exactly. - Changed inline values are applied with
--update-env. - Changed ecosystem values are followed by a restart or reload.
- The command points to the intended ecosystem file and script.
--onlylimits a multi-application restart when appropriate.- Startup validation fails clearly when a required value is missing.
- Production secrets are injected through a protected deployment process rather than committed as plaintext.
- Diagnostics reveal only safe metadata and do not print credentials.
- The deployment command explicitly records whether it uses the default, staging, or production block.
For a single experiment, the inline form is the shortest path. For any deployment that must be repeated or switched between staging and production, an ecosystem file with explicit env_* blocks is the safer operating pattern.
Frequently Asked Questions
How do I pass an environment variable to a Node.js app started by PM2?
Put the assignment before the start command, such as API_URL=https://api.example.com pm2 start app.js. The app reads it as process.env.API_URL. For repeatable configuration, place the variable in an ecosystem file’s env object.
Why is process.env undefined or missing a variable under PM2?
The variable was not supplied by the command, the selected ecosystem block, or the host environment. Check that the application uses the exact variable name, that the intended ecosystem file was started, and that required values are validated at startup. PM2 does not automatically parse every .env file.
Why did PM2 not pick up my changed environment variable?
Changed inline assignments require --update-env on restart or reload: NAME=new-value pm2 restart app --update-env. After editing an ecosystem file, restart or reload the app and use the same file and environment selector.
How do I use different .env values for production and staging with PM2?
Define env_production and env_staging objects in ecosystem.config.js, then run pm2 start ecosystem.config.js --env production or --env staging. PM2 does not treat arbitrary .env files as automatic; configure a separate loader if you use one.
Should production secrets be committed to an ecosystem file?
Avoid committing plaintext production credentials to a public repository. Use the host or deployment platform’s protected secret process to export values before PM2 starts, while keeping non-secret names and defaults in the ecosystem configuration.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →The Bottom Line
Use NAME=value pm2 start app.js for a one-off launch. For a running process, repeat the assignment with --update-env. For dependable staging and production deployments, define env, env_staging, and env_production in an ecosystem file, select the block with --env, and restart or reload after edits. Validate required values in Node.js and inject secrets through a protected deployment process.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
